/*
 * Copyright Codeplay Software Ltd.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use these files except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

// DO NOT MODIFY BY HAND
// This file was automatically generated by generate_depthwise_conv2d_tests.py.
// Results calculated using Tensorflow v1.12.0.

#include <gtest/gtest.h>

#include "sycldnn/padding_mode.h"

#include "test/types/cartesian_product.h"
#include "test/types/kernel_data_types.h"
#include "test/types/test_backend_types.h"
#include "test/types/to_gtest_types.h"

#include "test/depthwise_conv2d/window_stride_fixture.h"

#include <array>
#include <vector>

using DataTypeList = sycldnn::types::KernelDataTypes;
using Backends = sycldnn::types::DefaultBackendTypes;

using SNNTypePairs =
    sycldnn::types::CartesianProduct<DataTypeList, Backends>::type;
using GTestTypePairs = sycldnn::types::ToGTestTypes<SNNTypePairs>::type;

template <typename Pair>
using FilterBackpropWindow3Stride1 =
    sycldnn::depthwise_conv2d::WindowStrideTest<Pair, 3, 1>;
TYPED_TEST_SUITE(FilterBackpropWindow3Stride1, GTestTypePairs);
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x4x4x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {696.,  962., 732., 1112., 1496.,
                                         1112., 732., 962., 696.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x4x4x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {44.,  54.,  64.,  84., 94.,
                                         104., 124., 134., 144.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x4x4x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1338., 1392., 1846., 1924., 1401., 1464., 2128., 2224., 2856.,
      2992., 2116., 2224., 1374., 1464., 1798., 1924., 1293., 1392.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x4x4x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {74.,  88.,  90.,  108., 106., 128.,
                                         138., 168., 154., 188., 170., 208.,
                                         202., 248., 218., 268., 234., 288.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x4x4x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2622., 2676., 2730., 2784., 3614., 3692., 3770., 3848., 2739.,
      2802., 2865., 2928., 4160., 4256., 4352., 4448., 5576., 5712.,
      5848., 5984., 4124., 4232., 4340., 4448., 2658., 2748., 2838.,
      2928., 3470., 3596., 3722., 3848., 2487., 2586., 2685., 2784.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x4x4x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      134., 148., 162., 176., 162., 180., 198., 216., 190., 212., 234., 256.,
      246., 276., 306., 336., 274., 308., 342., 376., 302., 340., 378., 416.,
      358., 404., 450., 496., 386., 436., 486., 536., 414., 468., 522., 576.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x4x4x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2487., 2784., 3452., 3848., 2631., 2928., 4052., 4448., 5456.,
      5984., 4052., 4448., 2631., 2928., 3452., 3848., 2487., 2784.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x4x4x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {132., 176., 164., 216., 196., 256.,
                                         260., 336., 292., 376., 324., 416.,
                                         388., 496., 420., 536., 452., 576.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x4x4x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      4875.,  4974.,  5460., 5568., 6760., 6904., 7540., 7696.,  5145.,
      5262.,  5730.,  5856., 7924., 8104., 8704., 8896., 10656., 10912.,
      11696., 11968., 7900., 8104., 8680., 8896., 5091., 5262.,  5676.,
      5856.,  6664.,  6904., 7444., 7696., 4785., 4974., 5370.,  5568.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x4x4x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      240., 264., 324., 352., 296.,  328., 396., 432.,  352.,
      392., 468., 512., 464., 520.,  612., 672., 520.,  584.,
      684., 752., 576., 648., 756.,  832., 688., 776.,  900.,
      992., 744., 840., 972., 1072., 800., 904., 1044., 1152.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x4x4x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      9651.,  9750.,  9849.,  9948.,  10812., 10920., 11028., 11136., 13376.,
      13520., 13664., 13808., 14924., 15080., 15236., 15392., 10173., 10290.,
      10407., 10524., 11334., 11460., 11586., 11712., 15668., 15848., 16028.,
      16208., 17216., 17408., 17600., 17792., 21056., 21312., 21568., 21824.,
      23120., 23392., 23664., 23936., 15596., 15800., 16004., 16208., 17144.,
      17360., 17576., 17792., 10011., 10182., 10353., 10524., 11172., 11352.,
      11532., 11712., 13088., 13328., 13568., 13808., 14636., 14888., 15140.,
      15392., 9381.,  9570.,  9759.,  9948.,  10542., 10740., 10938., 11136.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x4x4x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      456.,  480.,  504.,  528.,  620.,  648.,  676.,  704.,  560.,
      592.,  624.,  656.,  756.,  792.,  828.,  864.,  664.,  704.,
      744.,  784.,  892.,  936.,  980.,  1024., 872.,  928.,  984.,
      1040., 1164., 1224., 1284., 1344., 976.,  1040., 1104., 1168.,
      1300., 1368., 1436., 1504., 1080., 1152., 1224., 1296., 1436.,
      1512., 1588., 1664., 1288., 1376., 1464., 1552., 1708., 1800.,
      1892., 1984., 1392., 1488., 1584., 1680., 1844., 1944., 2044.,
      2144., 1496., 1600., 1704., 1808., 1980., 2088., 2196., 2304.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x4x4x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      9381.,  9948.,  10533., 11136., 13052., 13808., 14588., 15392., 9957.,
      10524., 11109., 11712., 15452., 16208., 16988., 17792., 20816., 21824.,
      22864., 23936., 15452., 16208., 16988., 17792., 9957.,  10524., 11109.,
      11712., 13052., 13808., 14588., 15392., 9381.,  9948.,  10533., 11136.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x4x4x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      452.,  528.,  612.,  704.,  564.,  656.,  756.,  864.,  676.,
      784.,  900.,  1024., 900.,  1040., 1188., 1344., 1012., 1168.,
      1332., 1504., 1124., 1296., 1476., 1664., 1348., 1552., 1764.,
      1984., 1460., 1680., 1908., 2144., 1572., 1808., 2052., 2304.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x4x4x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      18573., 18762., 19698., 19896., 20859., 21066., 22056., 22272., 25828.,
      26104., 27328., 27616., 28876., 29176., 30472., 30784., 19689., 19914.,
      20814., 21048., 21975., 22218., 23172., 23424., 30556., 30904., 32056.,
      32416., 33604., 33976., 35200., 35584., 41136., 41632., 43136., 43648.,
      45200., 45728., 47328., 47872., 30508., 30904., 32008., 32416., 33556.,
      33976., 35152., 35584., 19581., 19914., 20706., 21048., 21867., 22218.,
      23064., 23424., 25636., 26104., 27136., 27616., 28684., 29176., 30280.,
      30784., 18393., 18762., 19518., 19896., 20679., 21066., 21876., 22272.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x4x4x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      860.,  904.,  1008., 1056., 1172., 1224., 1352., 1408., 1068.,
      1128., 1248., 1312., 1444., 1512., 1656., 1728., 1276., 1352.,
      1488., 1568., 1716., 1800., 1960., 2048., 1692., 1800., 1968.,
      2080., 2260., 2376., 2568., 2688., 1900., 2024., 2208., 2336.,
      2532., 2664., 2872., 3008., 2108., 2248., 2448., 2592., 2804.,
      2952., 3176., 3328., 2524., 2696., 2928., 3104., 3348., 3528.,
      3784., 3968., 2732., 2920., 3168., 3360., 3620., 3816., 4088.,
      4288., 2940., 3144., 3408., 3616., 3892., 4104., 4392., 4608.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x4x4x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      36957., 37146., 37335., 37524., 39198., 39396., 39594., 39792., 41511.,
      41718., 41925., 42132., 43896., 44112., 44328., 44544., 51380., 51656.,
      51932., 52208., 54368., 54656., 54944., 55232., 57452., 57752., 58052.,
      58352., 60632., 60944., 61256., 61568., 39153., 39378., 39603., 39828.,
      41394., 41628., 41862., 42096., 43707., 43950., 44193., 44436., 46092.,
      46344., 46596., 46848., 60764., 61112., 61460., 61808., 63752., 64112.,
      64472., 64832., 66836., 67208., 67580., 67952., 70016., 70400., 70784.,
      71168., 81776., 82272., 82768., 83264., 85760., 86272., 86784., 87296.,
      89872., 90400., 90928., 91456., 94112., 94656., 95200., 95744., 60620.,
      61016., 61412., 61808., 63608., 64016., 64424., 64832., 66692., 67112.,
      67532., 67952., 69872., 70304., 70736., 71168., 38829., 39162., 39495.,
      39828., 41070., 41412., 41754., 42096., 43383., 43734., 44085., 44436.,
      45768., 46128., 46488., 46848., 50804., 51272., 51740., 52208., 53792.,
      54272., 54752., 55232., 56876., 57368., 57860., 58352., 60056., 60560.,
      61064., 61568., 36417., 36786., 37155., 37524., 38658., 39036., 39414.,
      39792., 40971., 41358., 41745., 42132., 43356., 43752., 44148., 44544.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x4x4x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1676., 1720., 1764., 1808., 1968., 2016., 2064., 2112., 2292., 2344.,
      2396., 2448., 2648., 2704., 2760., 2816., 2076., 2136., 2196., 2256.,
      2432., 2496., 2560., 2624., 2820., 2888., 2956., 3024., 3240., 3312.,
      3384., 3456., 2476., 2552., 2628., 2704., 2896., 2976., 3056., 3136.,
      3348., 3432., 3516., 3600., 3832., 3920., 4008., 4096., 3276., 3384.,
      3492., 3600., 3824., 3936., 4048., 4160., 4404., 4520., 4636., 4752.,
      5016., 5136., 5256., 5376., 3676., 3800., 3924., 4048., 4288., 4416.,
      4544., 4672., 4932., 5064., 5196., 5328., 5608., 5744., 5880., 6016.,
      4076., 4216., 4356., 4496., 4752., 4896., 5040., 5184., 5460., 5608.,
      5756., 5904., 6200., 6352., 6504., 6656., 4876., 5048., 5220., 5392.,
      5680., 5856., 6032., 6208., 6516., 6696., 6876., 7056., 7384., 7568.,
      7752., 7936., 5276., 5464., 5652., 5840., 6144., 6336., 6528., 6720.,
      7044., 7240., 7436., 7632., 7976., 8176., 8376., 8576., 5676., 5880.,
      6084., 6288., 6608., 6816., 7024., 7232., 7572., 7784., 7996., 8208.,
      8568., 8784., 9000., 9216.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x4x5x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1430., 1840., 1490., 2280., 2870.,
                                         2280., 1490., 1840., 1430.};
  const std::array<int, 4> in_shape = {{1, 4, 5, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x4x5x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {121., 142., 163., 226., 247.,
                                         268., 331., 352., 373.};
  const std::array<int, 4> in_shape = {{1, 4, 5, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x4x5x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2770., 2860., 3560., 3680., 2878., 2980., 4400., 4560., 5530.,
      5740., 4384., 4560., 2830., 2980., 3485., 3680., 2698., 2860.};
  const std::array<int, 4> in_shape = {{1, 4, 5, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x4x5x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {215., 242., 251., 284., 287., 326.,
                                         395., 452., 431., 494., 467., 536.,
                                         575., 662., 611., 704., 647., 746.};
  const std::array<int, 4> in_shape = {{1, 4, 5, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x4x5x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5450.,  5540.,  5630., 5720., 7000., 7120., 7240., 7360.,  5654.,
      5756.,  5858.,  5960., 8640., 8800., 8960., 9120., 10850., 11060.,
      11270., 11480., 8592., 8768., 8944., 9120., 5510., 5660.,  5810.,
      5960.,  6775.,  6970., 7165., 7360., 5234., 5396., 5558.,  5720.};
  const std::array<int, 4> in_shape = {{1, 4, 5, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x4x5x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      403.,  430.,  457.,  484.,  469.,  502.,  535.,  568.,  535.,
      574.,  613.,  652.,  733.,  790.,  847.,  904.,  799.,  862.,
      925.,  988.,  865.,  934.,  1003., 1072., 1063., 1150., 1237.,
      1324., 1129., 1222., 1315., 1408., 1195., 1294., 1393., 1492.};
  const std::array<int, 4> in_shape = {{1, 4, 5, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x4x5x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5228.,  5720., 6745., 7360., 5468., 5960., 8464., 9120., 10660.,
      11480., 8464., 9120., 5468., 5960., 6745., 7360., 5228., 5720.};
  const std::array<int, 4> in_shape = {{1, 4, 5, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x4x5x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      394., 484., 466.,  568.,  538.,  652.,  754.,  904.,  826.,
      988., 898., 1072., 1114., 1324., 1186., 1408., 1258., 1492.};
  const std::array<int, 4> in_shape = {{1, 4, 5, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x4x5x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      10288., 10456., 11260., 11440., 13265., 13490., 14480., 14720., 10744.,
      10936., 11716., 11920., 16624., 16928., 17920., 18240., 20920., 21320.,
      22540., 22960., 16592., 16928., 17888., 18240., 10648., 10936., 11620.,
      11920., 13115., 13490., 14330., 14720., 10144., 10456., 11116., 11440.};
  const std::array<int, 4> in_shape = {{1, 4, 5, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x4x5x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      740.,  788.,  914.,  968.,  872.,  932.,  1070., 1136., 1004.,
      1076., 1226., 1304., 1400., 1508., 1694., 1808., 1532., 1652.,
      1850., 1976., 1664., 1796., 2006., 2144., 2060., 2228., 2474.,
      2648., 2192., 2372., 2630., 2816., 2324., 2516., 2786., 2984.};
  const std::array<int, 4> in_shape = {{1, 4, 5, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x4x5x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      20408., 20576., 20744., 20912., 22340., 22520., 22700., 22880., 26305.,
      26530., 26755., 26980., 28720., 28960., 29200., 29440., 21296., 21488.,
      21680., 21872., 23228., 23432., 23636., 23840., 32944., 33248., 33552.,
      33856., 35520., 35840., 36160., 36480., 41440., 41840., 42240., 42640.,
      44660., 45080., 45500., 45920., 32848., 33184., 33520., 33856., 35424.,
      35776., 36128., 36480., 21008., 21296., 21584., 21872., 22940., 23240.,
      23540., 23840., 25855., 26230., 26605., 26980., 28270., 28660., 29050.,
      29440., 19976., 20288., 20600., 20912., 21908., 22232., 22556., 22880.};
  const std::array<int, 4> in_shape = {{1, 4, 5, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x4x5x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1432., 1480., 1528., 1576., 1774., 1828., 1882., 1936., 1684.,
      1744., 1804., 1864., 2074., 2140., 2206., 2272., 1936., 2008.,
      2080., 2152., 2374., 2452., 2530., 2608., 2692., 2800., 2908.,
      3016., 3274., 3388., 3502., 3616., 2944., 3064., 3184., 3304.,
      3574., 3700., 3826., 3952., 3196., 3328., 3460., 3592., 3874.,
      4012., 4150., 4288., 3952., 4120., 4288., 4456., 4774., 4948.,
      5122., 5296., 4204., 4384., 4564., 4744., 5074., 5260., 5446.,
      5632., 4456., 4648., 4840., 5032., 5374., 5572., 5770., 5968.};
  const std::array<int, 4> in_shape = {{1, 4, 5, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x4x5x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      19964., 20912., 21884., 22880., 25795., 26980., 28195., 29440., 20924.,
      21872., 22844., 23840., 32592., 33856., 35152., 36480., 41060., 42640.,
      44260., 45920., 32592., 33856., 35152., 36480., 20924., 21872., 22844.,
      23840., 25795., 26980., 28195., 29440., 19964., 20912., 21884., 22880.};
  const std::array<int, 4> in_shape = {{1, 4, 5, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x4x5x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1414., 1576., 1750., 1936., 1678., 1864., 2062., 2272., 1942.,
      2152., 2374., 2608., 2734., 3016., 3310., 3616., 2998., 3304.,
      3622., 3952., 3262., 3592., 3934., 4288., 4054., 4456., 4870.,
      5296., 4318., 4744., 5182., 5632., 4582., 5032., 5494., 5968.};
  const std::array<int, 4> in_shape = {{1, 4, 5, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x4x5x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      39604., 39928., 41488., 41824., 43420., 43768., 45400., 45760., 51155.,
      51590., 53510., 53960., 55925., 56390., 58400., 58880., 41476., 41848.,
      43360., 43744., 45292., 45688., 47272., 47680., 64592., 65184., 67104.,
      67712., 69680., 70304., 72320., 72960., 81340., 82120., 84480., 85280.,
      87700., 88520., 91000., 91840., 64528., 65184., 67040., 67712., 69616.,
      70304., 72256., 72960., 41284., 41848., 43168., 43744., 45100., 45688.,
      47080., 47680., 50855., 51590., 53210., 53960., 55625., 56390., 58100.,
      58880., 39316., 39928., 41200., 41824., 43132., 43768., 45112., 45760.};
  const std::array<int, 4> in_shape = {{1, 4, 5, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x4x5x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2738.,  2828.,  3056., 3152., 3398.,  3500.,  3764.,  3872.,  3242.,
      3356.,  3608.,  3728., 3998., 4124.,  4412.,  4544.,  3746.,  3884.,
      4160.,  4304.,  4598., 4748., 5060.,  5216.,  5258.,  5468.,  5816.,
      6032.,  6398.,  6620., 7004., 7232.,  5762.,  5996.,  6368.,  6608.,
      6998.,  7244.,  7652., 7904., 6266.,  6524.,  6920.,  7184.,  7598.,
      7868.,  8300.,  8576., 7778., 8108.,  8576.,  8912.,  9398.,  9740.,
      10244., 10592., 8282., 8636., 9128.,  9488.,  9998.,  10364., 10892.,
      11264., 8786.,  9164., 9680., 10064., 10598., 10988., 11540., 11936.};
  const std::array<int, 4> in_shape = {{1, 4, 5, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x4x5x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      78884.,  79208.,  79532.,  79856.,  82640.,  82976.,  83312.,  83648.,
      86492.,  86840.,  87188.,  87536.,  90440.,  90800.,  91160.,  91520.,
      101875., 102310., 102745., 103180., 106570., 107020., 107470., 107920.,
      111385., 111850., 112315., 112780., 116320., 116800., 117280., 117760.,
      82580.,  82952.,  83324.,  83696.,  86336.,  86720.,  87104.,  87488.,
      90188.,  90584.,  90980.,  91376.,  94136.,  94544.,  94952.,  95360.,
      128592., 129184., 129776., 130368., 133600., 134208., 134816., 135424.,
      138736., 139360., 139984., 140608., 144000., 144640., 145280., 145920.,
      161900., 162680., 163460., 164240., 168160., 168960., 169760., 170560.,
      174580., 175400., 176220., 177040., 181160., 182000., 182840., 183680.,
      128400., 129056., 129712., 130368., 133408., 134080., 134752., 135424.,
      138544., 139232., 139920., 140608., 143808., 144512., 145216., 145920.,
      82004.,  82568.,  83132.,  83696.,  85760.,  86336.,  86912.,  87488.,
      89612.,  90200.,  90788.,  91376.,  93560.,  94160.,  94760.,  95360.,
      100975., 101710., 102445., 103180., 105670., 106420., 107170., 107920.,
      110485., 111250., 112015., 112780., 115420., 116200., 116980., 117760.,
      78020.,  78632.,  79244.,  79856.,  81776.,  82400.,  83024.,  83648.,
      85628.,  86264.,  86900.,  87536.,  89576.,  90224.,  90872.,  91520.};
  const std::array<int, 4> in_shape = {{1, 4, 5, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x4x5x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5386.,  5476.,  5566.,  5656.,  6016.,  6112.,  6208.,  6304.,  6694.,
      6796.,  6898.,  7000.,  7420.,  7528.,  7636.,  7744.,  6370.,  6484.,
      6598.,  6712.,  7096.,  7216.,  7336.,  7456.,  7870.,  7996.,  8122.,
      8248.,  8692.,  8824.,  8956.,  9088.,  7354.,  7492.,  7630.,  7768.,
      8176.,  8320.,  8464.,  8608.,  9046.,  9196.,  9346.,  9496.,  9964.,
      10120., 10276., 10432., 10306., 10516., 10726., 10936., 11416., 11632.,
      11848., 12064., 12574., 12796., 13018., 13240., 13780., 14008., 14236.,
      14464., 11290., 11524., 11758., 11992., 12496., 12736., 12976., 13216.,
      13750., 13996., 14242., 14488., 15052., 15304., 15556., 15808., 12274.,
      12532., 12790., 13048., 13576., 13840., 14104., 14368., 14926., 15196.,
      15466., 15736., 16324., 16600., 16876., 17152., 15226., 15556., 15886.,
      16216., 16816., 17152., 17488., 17824., 18454., 18796., 19138., 19480.,
      20140., 20488., 20836., 21184., 16210., 16564., 16918., 17272., 17896.,
      18256., 18616., 18976., 19630., 19996., 20362., 20728., 21412., 21784.,
      22156., 22528., 17194., 17572., 17950., 18328., 18976., 19360., 19744.,
      20128., 20806., 21196., 21586., 21976., 22684., 23080., 23476., 23872.};
  const std::array<int, 4> in_shape = {{1, 4, 5, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x4x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {2550., 3135., 2640., 4060., 4900.,
                                         4060., 2640., 3135., 2550.};
  const std::array<int, 4> in_shape = {{1, 4, 6, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x4x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {256., 292., 328., 472., 508.,
                                         544., 688., 724., 760.};
  const std::array<int, 4> in_shape = {{1, 4, 6, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x4x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      4965., 5100., 6099., 6270., 5130., 5280., 7880., 8120., 9500.,
      9800., 7860., 8120., 5055., 5280., 5991., 6270., 4860., 5100.};
  const std::array<int, 4> in_shape = {{1, 4, 6, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x4x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      468.,  512., 532.,  584.,  596.,  656.,  852.,  944.,  916.,
      1016., 980., 1088., 1236., 1376., 1300., 1448., 1364., 1520.};
  const std::array<int, 4> in_shape = {{1, 4, 6, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x4x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      9795.,  9930.,  10065., 10200., 12027., 12198., 12369., 12540., 10110.,
      10260., 10410., 10560., 15520., 15760., 16000., 16240., 18700., 19000.,
      19300., 19600., 15460., 15720., 15980., 16240., 9885.,  10110., 10335.,
      10560., 11703., 11982., 12261., 12540., 9480.,  9720.,  9960.,  10200.};
  const std::array<int, 4> in_shape = {{1, 4, 6, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x4x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      892.,  936.,  980.,  1024., 1012., 1064., 1116., 1168., 1132.,
      1192., 1252., 1312., 1612., 1704., 1796., 1888., 1732., 1832.,
      1932., 2032., 1852., 1960., 2068., 2176., 2332., 2472., 2612.,
      2752., 2452., 2600., 2748., 2896., 2572., 2728., 2884., 3040.};
  const std::array<int, 4> in_shape = {{1, 4, 6, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x4x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      9465.,  10200., 11658., 12540., 9825.,  10560., 15260., 16240., 18424.,
      19600., 15260., 16240., 9825.,  10560., 11658., 12540., 9465.,  10200.};
  const std::array<int, 4> in_shape = {{1, 4, 6, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x4x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      872.,  1024., 1000., 1168., 1128., 1312., 1640., 1888., 1768.,
      2032., 1896., 2176., 2408., 2752., 2536., 2896., 2664., 3040.};
  const std::array<int, 4> in_shape = {{1, 4, 6, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x4x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      18675., 18930., 20130., 20400., 22992., 23316., 24738., 25080., 19365.,
      19650., 20820., 21120., 30060., 30520., 32000., 32480., 36272., 36848.,
      38600., 39200., 30020., 30520., 31960., 32480., 19215., 19650., 20670.,
      21120., 22776., 23316., 24522., 25080., 18465., 18930., 19920., 20400.};
  const std::array<int, 4> in_shape = {{1, 4, 6, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x4x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1664., 1744., 1960., 2048., 1904., 2000., 2232., 2336., 2144.,
      2256., 2504., 2624., 3104., 3280., 3592., 3776., 3344., 3536.,
      3864., 4064., 3584., 3792., 4136., 4352., 4544., 4816., 5224.,
      5504., 4784., 5072., 5496., 5792., 5024., 5328., 5768., 6080.};
  const std::array<int, 4> in_shape = {{1, 4, 6, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x4x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      37095., 37350., 37605., 37860., 39990., 40260., 40530., 40800., 45660.,
      45984., 46308., 46632., 49134., 49476., 49818., 50160., 38445., 38730.,
      39015., 39300., 41340., 41640., 41940., 42240., 59660., 60120., 60580.,
      61040., 63520., 64000., 64480., 64960., 71968., 72544., 73120., 73696.,
      76600., 77200., 77800., 78400., 59540., 60040., 60540., 61040., 63400.,
      63920., 64440., 64960., 37995., 38430., 38865., 39300., 40890., 41340.,
      41790., 42240., 45012., 45552., 46092., 46632., 48486., 49044., 49602.,
      50160., 36465., 36930., 37395., 37860., 39360., 39840., 40320., 40800.};
  const std::array<int, 4> in_shape = {{1, 4, 6, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x4x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3248.,  3328.,  3408.,  3488.,  3832.,  3920.,  4008.,  4096.,  3712.,
      3808.,  3904.,  4000.,  4360.,  4464.,  4568.,  4672.,  4176.,  4288.,
      4400.,  4512.,  4888.,  5008.,  5128.,  5248.,  6032.,  6208.,  6384.,
      6560.,  7000.,  7184.,  7368.,  7552.,  6496.,  6688.,  6880.,  7072.,
      7528.,  7728.,  7928.,  8128.,  6960.,  7168.,  7376.,  7584.,  8056.,
      8272.,  8488.,  8704.,  8816.,  9088.,  9360.,  9632.,  10168., 10448.,
      10728., 11008., 9280.,  9568.,  9856.,  10144., 10696., 10992., 11288.,
      11584., 9744.,  10048., 10352., 10656., 11224., 11536., 11848., 12160.};
  const std::array<int, 4> in_shape = {{1, 4, 6, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x4x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      36435., 37860., 39315., 40800., 44922., 46632., 48378., 50160., 37875.,
      39300., 40755., 42240., 59140., 61040., 62980., 64960., 71416., 73696.,
      76024., 78400., 59140., 61040., 62980., 64960., 37875., 39300., 40755.,
      42240., 44922., 46632., 48378., 50160., 36435., 37860., 39315., 40800.};
  const std::array<int, 4> in_shape = {{1, 4, 6, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x4x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3208.,  3488., 3784.,  4096.,  3688.,  4000., 4328.,  4672.,  4168.,
      4512.,  4872., 5248.,  6088.,  6560.,  7048., 7552.,  6568.,  7072.,
      7592.,  8128., 7048.,  7584.,  8136.,  8704., 8968.,  9632.,  10312.,
      11008., 9448., 10144., 10856., 11584., 9928., 10656., 11400., 12160.};
  const std::array<int, 4> in_shape = {{1, 4, 6, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x4x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      72375.,  72870.,  75210.,  75720.,  78105.,  78630.,  81060.,  81600.,
      89214.,  89844.,  92616.,  93264.,  96090.,  96756.,  99636.,  100320.,
      75195.,  75750.,  78030.,  78600.,  80925.,  81510.,  83880.,  84480.,
      117380., 118280., 121160., 122080., 125020., 125960., 128960., 129920.,
      141704., 142832., 146240., 147392., 150872., 152048., 155600., 156800.,
      117300., 118280., 121080., 122080., 124940., 125960., 128880., 129920.,
      74895.,  75750.,  77730.,  78600.,  80625.,  81510.,  83580.,  84480.,
      88782.,  89844.,  92184.,  93264.,  95658.,  96756.,  99204.,  100320.,
      71955.,  72870.,  74790.,  75720.,  77685.,  78630.,  80640.,  81600.};
  const std::array<int, 4> in_shape = {{1, 4, 6, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x4x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      6264.,  6416.,  6816.,  6976.,  7400.,  7568.,  8016.,  8192.,  7192.,
      7376.,  7808.,  8000.,  8456.,  8656.,  9136.,  9344.,  8120.,  8336.,
      8800.,  9024.,  9512.,  9744.,  10256., 10496., 11832., 12176., 12768.,
      13120., 13736., 14096., 14736., 15104., 12760., 13136., 13760., 14144.,
      14792., 15184., 15856., 16256., 13688., 14096., 14752., 15168., 15848.,
      16272., 16976., 17408., 17400., 17936., 18720., 19264., 20072., 20624.,
      21456., 22016., 18328., 18896., 19712., 20288., 21128., 21712., 22576.,
      23168., 19256., 19856., 20704., 21312., 22184., 22800., 23696., 24320.};
  const std::array<int, 4> in_shape = {{1, 4, 6, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x4x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      144255., 144750., 145245., 145740., 149910., 150420., 150930., 151440.,
      155685., 156210., 156735., 157260., 161580., 162120., 162660., 163200.,
      177798., 178428., 179058., 179688., 184584., 185232., 185880., 186528.,
      191514., 192180., 192846., 193512., 198588., 199272., 199956., 200640.,
      149835., 150390., 150945., 151500., 155490., 156060., 156630., 157200.,
      161265., 161850., 162435., 163020., 167160., 167760., 168360., 168960.,
      233860., 234760., 235660., 236560., 241400., 242320., 243240., 244160.,
      249100., 250040., 250980., 251920., 256960., 257920., 258880., 259840.,
      282280., 283408., 284536., 285664., 291328., 292480., 293632., 294784.,
      300568., 301744., 302920., 304096., 310000., 311200., 312400., 313600.,
      233620., 234600., 235580., 236560., 241160., 242160., 243160., 244160.,
      248860., 249880., 250900., 251920., 256720., 257760., 258800., 259840.,
      148935., 149790., 150645., 151500., 154590., 155460., 156330., 157200.,
      160365., 161250., 162135., 163020., 166260., 167160., 168060., 168960.,
      176502., 177564., 178626., 179688., 183288., 184368., 185448., 186528.,
      190218., 191316., 192414., 193512., 197292., 198408., 199524., 200640.,
      142995., 143910., 144825., 145740., 148650., 149580., 150510., 151440.,
      154425., 155370., 156315., 157260., 160320., 161280., 162240., 163200.};
  const std::array<int, 4> in_shape = {{1, 4, 6, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x4x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      12376., 12528., 12680., 12832., 13472., 13632., 13792., 13952., 14632.,
      14800., 14968., 15136., 15856., 16032., 16208., 16384., 14200., 14384.,
      14568., 14752., 15424., 15616., 15808., 16000., 16712., 16912., 17112.,
      17312., 18064., 18272., 18480., 18688., 16024., 16240., 16456., 16672.,
      17376., 17600., 17824., 18048., 18792., 19024., 19256., 19488., 20272.,
      20512., 20752., 20992., 23320., 23664., 24008., 24352., 25184., 25536.,
      25888., 26240., 27112., 27472., 27832., 28192., 29104., 29472., 29840.,
      30208., 25144., 25520., 25896., 26272., 27136., 27520., 27904., 28288.,
      29192., 29584., 29976., 30368., 31312., 31712., 32112., 32512., 26968.,
      27376., 27784., 28192., 29088., 29504., 29920., 30336., 31272., 31696.,
      32120., 32544., 33520., 33952., 34384., 34816., 34264., 34800., 35336.,
      35872., 36896., 37440., 37984., 38528., 39592., 40144., 40696., 41248.,
      42352., 42912., 43472., 44032., 36088., 36656., 37224., 37792., 38848.,
      39424., 40000., 40576., 41672., 42256., 42840., 43424., 44560., 45152.,
      45744., 46336., 37912., 38512., 39112., 39712., 40800., 41408., 42016.,
      42624., 43752., 44368., 44984., 45600., 46768., 47392., 48016., 48640.};
  const std::array<int, 4> in_shape = {{1, 4, 6, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x5x4x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1496., 2040., 1544., 2140., 2870.,
                                         2140., 1544., 2040., 1496.};
  const std::array<int, 4> in_shape = {{1, 5, 4, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x5x4x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {149., 170., 191., 233., 254.,
                                         275., 317., 338., 359.};
  const std::array<int, 4> in_shape = {{1, 5, 4, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x5x4x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2896., 2992., 3944., 4080., 2980., 3088., 4130., 4280., 5530.,
      5740., 4115., 4280., 2944., 3088., 3880., 4080., 2836., 2992.};
  const std::array<int, 4> in_shape = {{1, 5, 4, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x5x4x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {265., 298., 301., 340., 337., 382.,
                                         409., 466., 445., 508., 481., 550.,
                                         553., 634., 589., 676., 625., 718.};
  const std::array<int, 4> in_shape = {{1, 5, 4, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x5x4x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5696.,  5792.,  5888., 5984., 7752., 7888., 8024., 8160.,  5852.,
      5960.,  6068.,  6176., 8110., 8260., 8410., 8560., 10850., 11060.,
      11270., 11480., 8065., 8230., 8395., 8560., 5744., 5888.,  6032.,
      6176.,  7560.,  7760., 7960., 8160., 5516., 5672., 5828.,  5984.};
  const std::array<int, 4> in_shape = {{1, 5, 4, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x5x4x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      497.,  530.,  563.,  596.,  563.,  602.,  641.,  680.,  629.,
      674.,  719.,  764.,  761.,  818.,  875.,  932.,  827.,  890.,
      953.,  1016., 893.,  962.,  1031., 1100., 1025., 1106., 1187.,
      1268., 1091., 1178., 1265., 1352., 1157., 1250., 1343., 1436.};
  const std::array<int, 4> in_shape = {{1, 5, 4, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x5x4x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5492.,  5984., 7504., 8160., 5684., 6176., 7945., 8560., 10660.,
      11480., 7945., 8560., 5684., 6176., 7504., 8160., 5492., 5984.};
  const std::array<int, 4> in_shape = {{1, 5, 4, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x5x4x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      494.,  596., 566.,  680.,  638.,  764.,  782.,  932.,  854.,
      1016., 926., 1100., 1070., 1268., 1142., 1352., 1214., 1436.};
  const std::array<int, 4> in_shape = {{1, 5, 4, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x5x4x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      10804., 10984., 11776., 11968., 14752., 15008., 16048., 16320., 11164.,
      11368., 12136., 12352., 15605., 15890., 16820., 17120., 20920., 21320.,
      22540., 22960., 15575., 15890., 16790., 17120., 11092., 11368., 12064.,
      12352., 14624., 15008., 15920., 16320., 10684., 10984., 11656., 11968.};
  const std::array<int, 4> in_shape = {{1, 5, 4, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x5x4x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      928.,  988.,  1126., 1192., 1060., 1132., 1282., 1360., 1192.,
      1276., 1438., 1528., 1456., 1564., 1750., 1864., 1588., 1708.,
      1906., 2032., 1720., 1852., 2062., 2200., 1984., 2140., 2374.,
      2536., 2116., 2284., 2530., 2704., 2248., 2428., 2686., 2872.};
  const std::array<int, 4> in_shape = {{1, 5, 4, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x5x4x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      21428., 21608., 21788., 21968., 23360., 23552., 23744., 23936., 29248.,
      29504., 29760., 30016., 31824., 32096., 32368., 32640., 22124., 22328.,
      22532., 22736., 24056., 24272., 24488., 24704., 30925., 31210., 31495.,
      31780., 33340., 33640., 33940., 34240., 41440., 41840., 42240., 42640.,
      44660., 45080., 45500., 45920., 30835., 31150., 31465., 31780., 33250.,
      33580., 33910., 34240., 21908., 22184., 22460., 22736., 23840., 24128.,
      24416., 24704., 28864., 29248., 29632., 30016., 31440., 31840., 32240.,
      32640., 21068., 21368., 21668., 21968., 23000., 23312., 23624., 23936.};
  const std::array<int, 4> in_shape = {{1, 5, 4, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x5x4x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1796., 1856., 1916., 1976., 2186., 2252., 2318., 2384., 2048.,
      2120., 2192., 2264., 2486., 2564., 2642., 2720., 2300., 2384.,
      2468., 2552., 2786., 2876., 2966., 3056., 2804., 2912., 3020.,
      3128., 3386., 3500., 3614., 3728., 3056., 3176., 3296., 3416.,
      3686., 3812., 3938., 4064., 3308., 3440., 3572., 3704., 3986.,
      4124., 4262., 4400., 3812., 3968., 4124., 4280., 4586., 4748.,
      4910., 5072., 4064., 4232., 4400., 4568., 4886., 5060., 5234.,
      5408., 4316., 4496., 4676., 4856., 5186., 5372., 5558., 5744.};
  const std::array<int, 4> in_shape = {{1, 5, 4, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x5x4x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      21020., 21968., 22940., 23936., 28752., 30016., 31312., 32640., 21788.,
      22736., 23708., 24704., 30595., 31780., 32995., 34240., 41060., 42640.,
      44260., 45920., 30595., 31780., 32995., 34240., 21788., 22736., 23708.,
      24704., 28752., 30016., 31312., 32640., 21020., 21968., 22940., 23936.};
  const std::array<int, 4> in_shape = {{1, 5, 4, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x5x4x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1790., 1976., 2174., 2384., 2054., 2264., 2486., 2720., 2318.,
      2552., 2798., 3056., 2846., 3128., 3422., 3728., 3110., 3416.,
      3734., 4064., 3374., 3704., 4046., 4400., 3902., 4280., 4670.,
      5072., 4166., 4568., 4982., 5408., 4430., 4856., 5294., 5744.};
  const std::array<int, 4> in_shape = {{1, 5, 4, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x5x4x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      41692., 42040., 43576., 43936., 45508., 45880., 47488., 47872., 57008.,
      57504., 59520., 60032., 62096., 62624., 64736., 65280., 43180., 43576.,
      45064., 45472., 46996., 47416., 48976., 49408., 60635., 61190., 62990.,
      63560., 65405., 65990., 67880., 68480., 81340., 82120., 84480., 85280.,
      87700., 88520., 91000., 91840., 60575., 61190., 62930., 63560., 65345.,
      65990., 67820., 68480., 43036., 43576., 44920., 45472., 46852., 47416.,
      48832., 49408., 56752., 57504., 59264., 60032., 61840., 62624., 64480.,
      65280., 41452., 42040., 43336., 43936., 45268., 45880., 47248., 47872.};
  const std::array<int, 4> in_shape = {{1, 5, 4, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x5x4x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3466.,  3580.,  3832., 3952., 4222., 4348.,  4636.,  4768.,  3970.,
      4108.,  4384.,  4528., 4822., 4972., 5284.,  5440.,  4474.,  4636.,
      4936.,  5104.,  5422., 5596., 5932., 6112.,  5482.,  5692.,  6040.,
      6256.,  6622.,  6844., 7228., 7456., 5986.,  6220.,  6592.,  6832.,
      7222.,  7468.,  7876., 8128., 6490., 6748.,  7144.,  7408.,  7822.,
      8092.,  8524.,  8800., 7498., 7804., 8248.,  8560.,  9022.,  9340.,
      9820.,  10144., 8002., 8332., 8800., 9136.,  9622.,  9964.,  10468.,
      10816., 8506.,  8860., 9352., 9712., 10222., 10588., 11116., 11488.};
  const std::array<int, 4> in_shape = {{1, 5, 4, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x5x4x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      83036.,  83384.,  83732.,  84080.,  86792.,  87152.,  87512.,  87872.,
      90644.,  91016.,  91388.,  91760.,  94592.,  94976.,  95360.,  95744.,
      113520., 114016., 114512., 115008., 118528., 119040., 119552., 120064.,
      123664., 124192., 124720., 125248., 128928., 129472., 130016., 130560.,
      85964.,  86360.,  86756.,  87152.,  89720.,  90128.,  90536.,  90944.,
      93572.,  93992.,  94412.,  94832.,  97520.,  97952.,  98384.,  98816.,
      120715., 121270., 121825., 122380., 125410., 125980., 126550., 127120.,
      130225., 130810., 131395., 131980., 135160., 135760., 136360., 136960.,
      161900., 162680., 163460., 164240., 168160., 168960., 169760., 170560.,
      174580., 175400., 176220., 177040., 181160., 182000., 182840., 183680.,
      120535., 121150., 121765., 122380., 125230., 125860., 126490., 127120.,
      130045., 130690., 131335., 131980., 134980., 135640., 136300., 136960.,
      85532.,  86072.,  86612.,  87152.,  89288.,  89840.,  90392.,  90944.,
      93140.,  93704.,  94268.,  94832.,  97088.,  97664.,  98240.,  98816.,
      112752., 113504., 114256., 115008., 117760., 118528., 119296., 120064.,
      122896., 123680., 124464., 125248., 128160., 128960., 129760., 130560.,
      82316.,  82904.,  83492.,  84080.,  86072.,  86672.,  87272.,  87872.,
      89924.,  90536.,  91148.,  91760.,  93872.,  94496.,  95120.,  95744.};
  const std::array<int, 4> in_shape = {{1, 5, 4, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x5x4x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      6818.,  6932.,  7046.,  7160.,  7544.,  7664.,  7784.,  7904.,  8318.,
      8444.,  8570.,  8696.,  9140.,  9272.,  9404.,  9536.,  7802.,  7940.,
      8078.,  8216.,  8624.,  8768.,  8912.,  9056.,  9494.,  9644.,  9794.,
      9944.,  10412., 10568., 10724., 10880., 8786.,  8948.,  9110.,  9272.,
      9704.,  9872.,  10040., 10208., 10670., 10844., 11018., 11192., 11684.,
      11864., 12044., 12224., 10754., 10964., 11174., 11384., 11864., 12080.,
      12296., 12512., 13022., 13244., 13466., 13688., 14228., 14456., 14684.,
      14912., 11738., 11972., 12206., 12440., 12944., 13184., 13424., 13664.,
      14198., 14444., 14690., 14936., 15500., 15752., 16004., 16256., 12722.,
      12980., 13238., 13496., 14024., 14288., 14552., 14816., 15374., 15644.,
      15914., 16184., 16772., 17048., 17324., 17600., 14690., 14996., 15302.,
      15608., 16184., 16496., 16808., 17120., 17726., 18044., 18362., 18680.,
      19316., 19640., 19964., 20288., 15674., 16004., 16334., 16664., 17264.,
      17600., 17936., 18272., 18902., 19244., 19586., 19928., 20588., 20936.,
      21284., 21632., 16658., 17012., 17366., 17720., 18344., 18704., 19064.,
      19424., 20078., 20444., 20810., 21176., 21860., 22232., 22604., 22976.};
  const std::array<int, 4> in_shape = {{1, 5, 4, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x5x5x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {3080., 3920., 3160., 4400., 5525.,
                                         4400., 3160., 3920., 3080.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x5x5x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {411., 456., 501., 636., 681.,
                                         726., 861., 906., 951.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x5x5x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      6000.,  6160., 7630., 7840., 6144., 6320., 8550., 8800., 10725.,
      11050., 8530., 8800., 6080., 6320., 7530., 7840., 5904., 6160.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x5x5x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      759.,  822.,  840.,  912.,  921.,  1002., 1164., 1272., 1245.,
      1362., 1326., 1452., 1569., 1722., 1650., 1812., 1731., 1902.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x5x5x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      11840., 12000., 12160., 12320., 15050., 15260., 15470., 15680., 12112.,
      12288., 12464., 12640., 16850., 17100., 17350., 17600., 21125., 21450.,
      21775., 22100., 16790., 17060., 17330., 17600., 11920., 12160., 12400.,
      12640., 14750., 15060., 15370., 15680., 11552., 11808., 12064., 12320.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x5x5x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1455., 1518., 1581., 1644., 1608., 1680., 1752., 1824., 1761.,
      1842., 1923., 2004., 2220., 2328., 2436., 2544., 2373., 2490.,
      2607., 2724., 2526., 2652., 2778., 2904., 2985., 3138., 3291.,
      3444., 3138., 3300., 3462., 3624., 3291., 3462., 3633., 3804.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x5x5x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      11504., 12320., 14660., 15680., 11824., 12640., 16580., 17600., 20825.,
      22100., 16580., 17600., 11824., 12640., 14660., 15680., 11504., 12320.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x5x5x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1437., 1644., 1599., 1824., 1761., 2004., 2247., 2544., 2409.,
      2724., 2571., 2904., 3057., 3444., 3219., 3624., 3381., 3804.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x5x5x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      22704., 23008., 24320., 24640., 28920., 29320., 30940., 31360., 23312.,
      23648., 24928., 25280., 32680., 33160., 34700., 35200., 41025., 41650.,
      43550., 44200., 32640., 33160., 34660., 35200., 23184., 23648., 24800.,
      25280., 28720., 29320., 30740., 31360., 22512., 23008., 24128., 24640.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x5x5x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2757., 2874., 3162., 3288., 3063., 3198., 3504., 3648., 3369.,
      3522., 3846., 4008., 4287., 4494., 4872., 5088., 4593., 4818.,
      5214., 5448., 4899., 5142., 5556., 5808., 5817., 6114., 6582.,
      6888., 6123., 6438., 6924., 7248., 6429., 6762., 7266., 7608.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x5x5x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      45104., 45408., 45712., 46016., 48320., 48640., 48960., 49280., 57440.,
      57840., 58240., 58640., 61460., 61880., 62300., 62720., 46288., 46624.,
      46960., 47296., 49504., 49856., 50208., 50560., 64880., 65360., 65840.,
      66320., 68900., 69400., 69900., 70400., 81425., 82050., 82675., 83300.,
      86450., 87100., 87750., 88400., 64760., 65280., 65800., 66320., 68780.,
      69320., 69860., 70400., 45904., 46368., 46832., 47296., 49120., 49600.,
      50080., 50560., 56840., 57440., 58040., 58640., 60860., 61480., 62100.,
      62720., 44528., 45024., 45520., 46016., 47744., 48256., 48768., 49280.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x5x5x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5397.,  5514.,  5631.,  5748.,  6198.,  6324.,  6450.,  6576.,  5991.,
      6126.,  6261.,  6396.,  6864.,  7008.,  7152.,  7296.,  6585.,  6738.,
      6891.,  7044.,  7530.,  7692.,  7854.,  8016.,  8367.,  8574.,  8781.,
      8988.,  9528.,  9744.,  9960.,  10176., 8961.,  9186.,  9411.,  9636.,
      10194., 10428., 10662., 10896., 9555.,  9798.,  10041., 10284., 10860.,
      11112., 11364., 11616., 11337., 11634., 11931., 12228., 12858., 13164.,
      13470., 13776., 11931., 12246., 12561., 12876., 13524., 13848., 14172.,
      14496., 12525., 12858., 13191., 13524., 14190., 14532., 14874., 15216.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x5x5x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      44432., 46016., 47632., 49280., 56660., 58640., 60660., 62720., 45712.,
      47296., 48912., 50560., 64340., 66320., 68340., 70400., 80825., 83300.,
      85825., 88400., 64340., 66320., 68340., 70400., 45712., 47296., 48912.,
      50560., 56660., 58640., 60660., 62720., 44432., 46016., 47632., 49280.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x5x5x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5361.,  5748.,  6153.,  6576.,  5973.,  6396.,  6837.,  7296.,  6585.,
      7044.,  7521.,  8016.,  8421.,  8988.,  9573.,  10176., 9033.,  9636.,
      10257., 10896., 9645.,  10284., 10941., 11616., 11481., 12228., 12993.,
      13776., 12093., 12876., 13677., 14496., 12705., 13524., 14361., 15216.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x5x5x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      88272.,  88864.,  91424.,  92032.,  94640.,  95264.,  97920.,  98560.,
      112540., 113320., 116480., 117280., 120500., 121320., 124600., 125440.,
      90768.,  91424.,  93920.,  94592.,  97136.,  97824.,  100416., 101120.,
      127740., 128680., 131680., 132640., 135700., 136680., 139800., 140800.,
      160425., 161650., 165350., 166600., 170375., 171650., 175500., 176800.,
      127660., 128680., 131600., 132640., 135620., 136680., 139720., 140800.,
      90512.,  91424.,  93664.,  94592.,  96880.,  97824.,  100160., 101120.,
      112140., 113320., 116080., 117280., 120100., 121320., 124200., 125440.,
      87888.,  88864.,  91040.,  92032.,  94256.,  95264.,  97536.,  98560.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x5x5x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      10497., 10722., 11262., 11496., 12063., 12306., 12900., 13152., 11685.,
      11946., 12522., 12792., 13395., 13674., 14304., 14592., 12873., 13170.,
      13782., 14088., 14727., 15042., 15708., 16032., 16437., 16842., 17562.,
      17976., 18723., 19146., 19920., 20352., 17625., 18066., 18822., 19272.,
      20055., 20514., 21324., 21792., 18813., 19290., 20082., 20568., 21387.,
      21882., 22728., 23232., 22377., 22962., 23862., 24456., 25383., 25986.,
      26940., 27552., 23565., 24186., 25122., 25752., 26715., 27354., 28344.,
      28992., 24753., 25410., 26382., 27048., 28047., 28722., 29748., 30432.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x5x5x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      175952., 176544., 177136., 177728., 182240., 182848., 183456., 184064.,
      188656., 189280., 189904., 190528., 195200., 195840., 196480., 197120.,
      224300., 225080., 225860., 226640., 232160., 232960., 233760., 234560.,
      240180., 241000., 241820., 242640., 248360., 249200., 250040., 250880.,
      180880., 181536., 182192., 182848., 187168., 187840., 188512., 189184.,
      193584., 194272., 194960., 195648., 200128., 200832., 201536., 202240.,
      254540., 255480., 256420., 257360., 262400., 263360., 264320., 265280.,
      270420., 271400., 272380., 273360., 278600., 279600., 280600., 281600.,
      319625., 320850., 322075., 323300., 329450., 330700., 331950., 333200.,
      339475., 340750., 342025., 343300., 349700., 351000., 352300., 353600.,
      254300., 255320., 256340., 257360., 262160., 263200., 264240., 265280.,
      270180., 271240., 272300., 273360., 278360., 279440., 280520., 281600.,
      180112., 181024., 181936., 182848., 186400., 187328., 188256., 189184.,
      192816., 193760., 194704., 195648., 199360., 200320., 201280., 202240.,
      223100., 224280., 225460., 226640., 230960., 232160., 233360., 234560.,
      238980., 240200., 241420., 242640., 247160., 248400., 249640., 250880.,
      174800., 175776., 176752., 177728., 181088., 182080., 183072., 184064.,
      187504., 188512., 189520., 190528., 194048., 195072., 196096., 197120.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x5x5x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      20769., 20994., 21219., 21444., 22290., 22524., 22758., 22992., 23883.,
      24126., 24369., 24612., 25548., 25800., 26052., 26304., 23109., 23370.,
      23631., 23892., 24774., 25044., 25314., 25584., 26511., 26790., 27069.,
      27348., 28320., 28608., 28896., 29184., 25449., 25746., 26043., 26340.,
      27258., 27564., 27870., 28176., 29139., 29454., 29769., 30084., 31092.,
      31416., 31740., 32064., 32469., 32874., 33279., 33684., 34710., 35124.,
      35538., 35952., 37023., 37446., 37869., 38292., 39408., 39840., 40272.,
      40704., 34809., 35250., 35691., 36132., 37194., 37644., 38094., 38544.,
      39651., 40110., 40569., 41028., 42180., 42648., 43116., 43584., 37149.,
      37626., 38103., 38580., 39678., 40164., 40650., 41136., 42279., 42774.,
      43269., 43764., 44952., 45456., 45960., 46464., 44169., 44754., 45339.,
      45924., 47130., 47724., 48318., 48912., 50163., 50766., 51369., 51972.,
      53268., 53880., 54492., 55104., 46509., 47130., 47751., 48372., 49614.,
      50244., 50874., 51504., 52791., 53430., 54069., 54708., 56040., 56688.,
      57336., 57984., 48849., 49506., 50163., 50820., 52098., 52764., 53430.,
      54096., 55419., 56094., 56769., 57444., 58812., 59496., 60180., 60864.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x5x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {5500., 6700., 5620., 7850., 9455.,
                                         7850., 5620., 6700., 5500.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x5x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {870.,  948.,  1026., 1338., 1416.,
                                         1494., 1806., 1884., 1962.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x5x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      10760., 11000., 13100., 13400., 10980., 11240., 15325., 15700., 18445.,
      18910., 15300., 15700., 10880., 11240., 12956., 13400., 10620., 11000.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x5x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1638., 1740., 1782., 1896., 1926., 2052., 2502., 2676., 2646.,
      2832., 2790., 2988., 3366., 3612., 3510., 3768., 3654., 3924.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x5x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      21280., 21520., 21760., 22000., 25900., 26200., 26500., 26800., 21700.,
      21960., 22220., 22480., 30275., 30650., 31025., 31400., 36425., 36890.,
      37355., 37820., 30200., 30600., 31000., 31400., 21400., 21760., 22120.,
      22480., 25468., 25912., 26356., 26800., 20860., 21240., 21620., 22000.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x5x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3174., 3276., 3378., 3480., 3450., 3564., 3678., 3792., 3726.,
      3852., 3978., 4104., 4830., 5004., 5178., 5352., 5106., 5292.,
      5478., 5664., 5382., 5580., 5778., 5976., 6486., 6732., 6978.,
      7224., 6762., 7020., 7278., 7536., 7038., 7308., 7578., 7848.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x5x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      20780., 22000., 25336., 26800., 21260., 22480., 29875., 31400., 35990.,
      37820., 29875., 31400., 21260., 22480., 25336., 26800., 20780., 22000.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x5x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3132., 3480., 3420., 3792., 3708., 4104., 4860., 5352., 5148.,
      5664., 5436., 5976., 6588., 7224., 6876., 7536., 7164., 7848.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x5x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      41100., 41560., 43520., 44000., 50096., 50672., 53000., 53600., 42020.,
      42520., 44440., 44960., 59025., 59750., 62050., 62800., 71080., 71980.,
      74710., 75640., 58975., 59750., 62000., 62800., 41820., 42520., 44240.,
      44960., 49808., 50672., 52712., 53600., 40820., 41560., 43240., 44000.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x5x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      6072.,  6264.,  6756.,  6960.,  6624.,  6840.,  7356.,  7584.,  7176.,
      7416.,  7956.,  8208.,  9384.,  9720.,  10356., 10704., 9936.,  10296.,
      10956., 11328., 10488., 10872., 11556., 11952., 12696., 13176., 13956.,
      14448., 13248., 13752., 14556., 15072., 13800., 14328., 15156., 15696.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x5x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      81740.,  82200.,  82660.,  83120.,  86560.,  87040.,  87520.,  88000.,
      99616.,  100192., 100768., 101344., 105400., 106000., 106600., 107200.,
      83540.,  84040.,  84540.,  85040.,  88360.,  88880.,  89400.,  89920.,
      117325., 118050., 118775., 119500., 123350., 124100., 124850., 125600.,
      141260., 142160., 143060., 143960., 148490., 149420., 150350., 151280.,
      117175., 117950., 118725., 119500., 123200., 124000., 124800., 125600.,
      82940.,  83640.,  84340.,  85040.,  87760.,  88480.,  89200.,  89920.,
      98752.,  99616.,  100480., 101344., 104536., 105424., 106312., 107200.,
      80900.,  81640.,  82380.,  83120.,  85720.,  86480.,  87240.,  88000.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x5x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      11952., 12144., 12336., 12528., 13308., 13512., 13716., 13920., 13032.,
      13248., 13464., 13680., 14484., 14712., 14940., 15168., 14112., 14352.,
      14592., 14832., 15660., 15912., 16164., 16416., 18432., 18768., 19104.,
      19440., 20364., 20712., 21060., 21408., 19512., 19872., 20232., 20592.,
      21540., 21912., 22284., 22656., 20592., 20976., 21360., 21744., 22716.,
      23112., 23508., 23904., 24912., 25392., 25872., 26352., 27420., 27912.,
      28404., 28896., 25992., 26496., 27000., 27504., 28596., 29112., 29628.,
      30144., 27072., 27600., 28128., 28656., 29772., 30312., 30852., 31392.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x5x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      80740.,  83120.,  85540.,  88000.,  98488.,  101344., 104248., 107200.,
      82660.,  85040.,  87460.,  89920.,  116525., 119500., 122525., 125600.,
      140390., 143960., 147590., 151280., 116525., 119500., 122525., 125600.,
      82660.,  85040.,  87460.,  89920.,  98488.,  101344., 104248., 107200.,
      80740.,  83120.,  85540.,  88000.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x5x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      11868., 12528., 13212., 13920., 12972., 13680., 14412., 15168., 14076.,
      14832., 15612., 16416., 18492., 19440., 20412., 21408., 19596., 20592.,
      21612., 22656., 20700., 21744., 22812., 23904., 25116., 26352., 27612.,
      28896., 26220., 27504., 28812., 30144., 27324., 28656., 30012., 31392.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x5x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      160580., 161480., 165320., 166240., 170140., 171080., 175040., 176000.,
      195848., 196976., 201536., 202688., 207320., 208496., 213200., 214400.,
      164340., 165320., 169080., 170080., 173900., 174920., 178800., 179840.,
      231625., 233050., 237550., 239000., 243575., 245050., 249700., 251200.,
      279010., 280780., 286120., 287920., 293350., 295180., 300700., 302560.,
      231525., 233050., 237450., 239000., 243475., 245050., 249600., 251200.,
      163940., 165320., 168680., 170080., 173500., 174920., 178400., 179840.,
      195272., 196976., 200960., 202688., 206744., 208496., 212624., 214400.,
      160020., 161480., 164760., 166240., 169580., 171080., 174480., 176000.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x5x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      23364., 23736., 24672., 25056., 26028., 26424., 27432., 27840., 25524.,
      25944., 26928., 27360., 28380., 28824., 29880., 30336., 27684., 28152.,
      29184., 29664., 30732., 31224., 32328., 32832., 36324., 36984., 38208.,
      38880., 40140., 40824., 42120., 42816., 38484., 39192., 40464., 41184.,
      42492., 43224., 44568., 45312., 40644., 41400., 42720., 43488., 44844.,
      45624., 47016., 47808., 49284., 50232., 51744., 52704., 54252., 55224.,
      56808., 57792., 51444., 52440., 54000., 55008., 56604., 57624., 59256.,
      60288., 53604., 54648., 56256., 57312., 58956., 60024., 61704., 62784.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x5x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      320260., 321160., 322060., 322960., 329720., 330640., 331560., 332480.,
      339340., 340280., 341220., 342160., 349120., 350080., 351040., 352000.,
      390568., 391696., 392824., 393952., 401920., 403072., 404224., 405376.,
      413464., 414640., 415816., 416992., 425200., 426400., 427600., 428800.,
      327700., 328680., 329660., 330640., 337160., 338160., 339160., 340160.,
      346780., 347800., 348820., 349840., 356560., 357600., 358640., 359680.,
      461825., 463250., 464675., 466100., 473650., 475100., 476550., 478000.,
      485675., 487150., 488625., 490100., 497900., 499400., 500900., 502400.,
      556250., 558020., 559790., 561560., 570440., 572240., 574040., 575840.,
      584870., 586700., 588530., 590360., 599540., 601400., 603260., 605120.,
      461525., 463050., 464575., 466100., 473350., 474900., 476450., 478000.,
      485375., 486950., 488525., 490100., 497600., 499200., 500800., 502400.,
      326500., 327880., 329260., 330640., 335960., 337360., 338760., 340160.,
      345580., 347000., 348420., 349840., 355360., 356800., 358240., 359680.,
      388840., 390544., 392248., 393952., 400192., 401920., 403648., 405376.,
      411736., 413488., 415240., 416992., 423472., 425248., 427024., 428800.,
      318580., 320040., 321500., 322960., 328040., 329520., 331000., 332480.,
      337660., 339160., 340660., 342160., 347440., 348960., 350480., 352000.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x5x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      46356.,  46728.,  47100.,  47472.,  48960.,  49344.,  49728.,  50112.,
      51660.,  52056.,  52452.,  52848.,  54456.,  54864.,  55272.,  55680.,
      50628.,  51048.,  51468.,  51888.,  53424.,  53856.,  54288.,  54720.,
      56316.,  56760.,  57204.,  57648.,  59304.,  59760.,  60216.,  60672.,
      54900.,  55368.,  55836.,  56304.,  57888.,  58368.,  58848.,  59328.,
      60972.,  61464.,  61956.,  62448.,  64152.,  64656.,  65160.,  65664.,
      71988.,  72648.,  73308.,  73968.,  75744.,  76416.,  77088.,  77760.,
      79596.,  80280.,  80964.,  81648.,  83544.,  84240.,  84936.,  85632.,
      76260.,  76968.,  77676.,  78384.,  80208.,  80928.,  81648.,  82368.,
      84252.,  84984.,  85716.,  86448.,  88392.,  89136.,  89880.,  90624.,
      80532.,  81288.,  82044.,  82800.,  84672.,  85440.,  86208.,  86976.,
      88908.,  89688.,  90468.,  91248.,  93240.,  94032.,  94824.,  95616.,
      97620.,  98568.,  99516.,  100464., 102528., 103488., 104448., 105408.,
      107532., 108504., 109476., 110448., 112632., 113616., 114600., 115584.,
      101892., 102888., 103884., 104880., 106992., 108000., 109008., 110016.,
      112188., 113208., 114228., 115248., 117480., 118512., 119544., 120576.,
      106164., 107208., 108252., 109296., 111456., 112512., 113568., 114624.,
      116844., 117912., 118980., 120048., 122328., 123408., 124488., 125568.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x6x4x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {2740., 3710., 2800., 3660., 4900.,
                                         3660., 2800., 3710., 2740.};
  const std::array<int, 4> in_shape = {{1, 6, 4, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x6x4x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {352., 388., 424., 496., 532.,
                                         568., 640., 676., 712.};
  const std::array<int, 4> in_shape = {{1, 6, 4, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x6x4x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5330., 5480., 7210., 7420., 5435., 5600., 7104., 7320., 9500.,
      9800., 7086., 7320., 5390., 5600., 7130., 7420., 5255., 5480.};
  const std::array<int, 4> in_shape = {{1, 6, 4, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x6x4x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      644.,  704.,  708.,  776.,  772.,  848.,  900.,  992.,  964.,
      1064., 1028., 1136., 1156., 1280., 1220., 1352., 1284., 1424.};
  const std::array<int, 4> in_shape = {{1, 6, 4, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x6x4x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      10510., 10660., 10810., 10960., 14210., 14420., 14630., 14840., 10705.,
      10870., 11035., 11200., 13992., 14208., 14424., 14640., 18700., 19000.,
      19300., 19600., 13938., 14172., 14406., 14640., 10570., 10780., 10990.,
      11200., 13970., 14260., 14550., 14840., 10285., 10510., 10735., 10960.};
  const std::array<int, 4> in_shape = {{1, 6, 4, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x6x4x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1228., 1288., 1348., 1408., 1348., 1416., 1484., 1552., 1468.,
      1544., 1620., 1696., 1708., 1800., 1892., 1984., 1828., 1928.,
      2028., 2128., 1948., 2056., 2164., 2272., 2188., 2312., 2436.,
      2560., 2308., 2440., 2572., 2704., 2428., 2568., 2708., 2848.};
  const std::array<int, 4> in_shape = {{1, 6, 4, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x6x4x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      10225., 10960., 13860., 14840., 10465., 11200., 13758., 14640., 18424.,
      19600., 13758., 14640., 10465., 11200., 13860., 14840., 10225., 10960.};
  const std::array<int, 4> in_shape = {{1, 6, 4, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x6x4x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1224., 1408., 1352., 1552., 1480., 1696., 1736., 1984., 1864.,
      2128., 1992., 2272., 2248., 2560., 2376., 2704., 2504., 2848.};
  const std::array<int, 4> in_shape = {{1, 6, 4, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x6x4x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      20165., 20450., 21620., 21920., 27320., 27720., 29260., 29680., 20615.,
      20930., 22070., 22400., 27102., 27516., 28848., 29280., 36272., 36848.,
      38600., 39200., 27066., 27516., 28812., 29280., 20525., 20930., 21980.,
      22400., 27160., 27720., 29100., 29680., 20015., 20450., 21470., 21920.};
  const std::array<int, 4> in_shape = {{1, 6, 4, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x6x4x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2336., 2448., 2696., 2816., 2576., 2704., 2968., 3104., 2816.,
      2960., 3240., 3392., 3296., 3472., 3784., 3968., 3536., 3728.,
      4056., 4256., 3776., 3984., 4328., 4544., 4256., 4496., 4872.,
      5120., 4496., 4752., 5144., 5408., 4736., 5008., 5416., 5696.};
  const std::array<int, 4> in_shape = {{1, 6, 4, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x6x4x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      40045., 40330., 40615., 40900., 42940., 43240., 43540., 43840., 54240.,
      54640., 55040., 55440., 58100., 58520., 58940., 59360., 40915., 41230.,
      41545., 41860., 43810., 44140., 44470., 44800., 53790., 54204., 54618.,
      55032., 57264., 57696., 58128., 58560., 71968., 72544., 73120., 73696.,
      76600., 77200., 77800., 78400., 53682., 54132., 54582., 55032., 57156.,
      57624., 58092., 58560., 40645., 41050., 41455., 41860., 43540., 43960.,
      44380., 44800., 53760., 54320., 54880., 55440., 57620., 58200., 58780.,
      59360., 39595., 40030., 40465., 40900., 42490., 42940., 43390., 43840.};
  const std::array<int, 4> in_shape = {{1, 6, 4, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x6x4x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      4560.,  4672.,  4784., 4896., 5272.,  5392.,  5512.,  5632.,  5024.,
      5152.,  5280.,  5408., 5800., 5936.,  6072.,  6208.,  5488.,  5632.,
      5776.,  5920.,  6328., 6480., 6632.,  6784.,  6416.,  6592.,  6768.,
      6944.,  7384.,  7568., 7752., 7936.,  6880.,  7072.,  7264.,  7456.,
      7912.,  8112.,  8312., 8512., 7344.,  7552.,  7760.,  7968.,  8440.,
      8656.,  8872.,  9088., 8272., 8512.,  8752.,  8992.,  9496.,  9744.,
      9992.,  10240., 8736., 8992., 9248.,  9504.,  10024., 10288., 10552.,
      10816., 9200.,  9472., 9744., 10016., 10552., 10832., 11112., 11392.};
  const std::array<int, 4> in_shape = {{1, 6, 4, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x6x4x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      39475., 40900., 42355., 43840., 53540., 55440., 57380., 59360., 40435.,
      41860., 43315., 44800., 53322., 55032., 56778., 58560., 71416., 73696.,
      76024., 78400., 53322., 55032., 56778., 58560., 40435., 41860., 43315.,
      44800., 53540., 55440., 57380., 59360., 39475., 40900., 42355., 43840.};
  const std::array<int, 4> in_shape = {{1, 6, 4, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x6x4x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      4552.,  4896., 5256., 5632.,  5032.,  5408., 5800.,  6208.,  5512.,
      5920.,  6344., 6784., 6472.,  6944.,  7432., 7936.,  6952.,  7456.,
      7976.,  8512., 7432., 7968.,  8520.,  9088., 8392.,  8992.,  9608.,
      10240., 8872., 9504., 10152., 10816., 9352., 10016., 10696., 11392.};
  const std::array<int, 4> in_shape = {{1, 6, 4, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x6x4x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      78395.,  78950.,  81230.,  81800.,  84125.,  84710.,  87080.,  87680.,
      106300., 107080., 110080., 110880., 113940., 114760., 117880., 118720.,
      80255.,  80870.,  83090.,  83720.,  85985.,  86630.,  88940.,  89600.,
      105834., 106644., 109236., 110064., 112710., 113556., 116256., 117120.,
      141704., 142832., 146240., 147392., 150872., 152048., 155600., 156800.,
      105762., 106644., 109164., 110064., 112638., 113556., 116184., 117120.,
      80075.,  80870.,  82910.,  83720.,  85805.,  86630.,  88760.,  89600.,
      105980., 107080., 109760., 110880., 113620., 114760., 117560., 118720.,
      78095.,  78950.,  80930.,  81800.,  83825.,  84710.,  86780.,  87680.};
  const std::array<int, 4> in_shape = {{1, 6, 4, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x6x4x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      8888.,  9104.,  9568.,  9792.,  10280., 10512., 11024., 11264., 9816.,
      10064., 10560., 10816., 11336., 11600., 12144., 12416., 10744., 11024.,
      11552., 11840., 12392., 12688., 13264., 13568., 12600., 12944., 13536.,
      13888., 14504., 14864., 15504., 15872., 13528., 13904., 14528., 14912.,
      15560., 15952., 16624., 17024., 14456., 14864., 15520., 15936., 16616.,
      17040., 17744., 18176., 16312., 16784., 17504., 17984., 18728., 19216.,
      19984., 20480., 17240., 17744., 18496., 19008., 19784., 20304., 21104.,
      21632., 18168., 18704., 19488., 20032., 20840., 21392., 22224., 22784.};
  const std::array<int, 4> in_shape = {{1, 6, 4, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x6x4x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      156235., 156790., 157345., 157900., 161890., 162460., 163030., 163600.,
      167665., 168250., 168835., 169420., 173560., 174160., 174760., 175360.,
      211820., 212600., 213380., 214160., 219360., 220160., 220960., 221760.,
      227060., 227880., 228700., 229520., 234920., 235760., 236600., 237440.,
      159895., 160510., 161125., 161740., 165550., 166180., 166810., 167440.,
      171325., 171970., 172615., 173260., 177220., 177880., 178540., 179200.,
      210858., 211668., 212478., 213288., 217644., 218472., 219300., 220128.,
      224574., 225420., 226266., 227112., 231648., 232512., 233376., 234240.,
      282280., 283408., 284536., 285664., 291328., 292480., 293632., 294784.,
      300568., 301744., 302920., 304096., 310000., 311200., 312400., 313600.,
      210642., 211524., 212406., 213288., 217428., 218328., 219228., 220128.,
      224358., 225276., 226194., 227112., 231432., 232368., 233304., 234240.,
      159355., 160150., 160945., 161740., 165010., 165820., 166630., 167440.,
      170785., 171610., 172435., 173260., 176680., 177520., 178360., 179200.,
      210860., 211960., 213060., 214160., 218400., 219520., 220640., 221760.,
      226100., 227240., 228380., 229520., 233960., 235120., 236280., 237440.,
      155335., 156190., 157045., 157900., 160990., 161860., 162730., 163600.,
      166765., 167650., 168535., 169420., 172660., 173560., 174460., 175360.};
  const std::array<int, 4> in_shape = {{1, 6, 4, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x6x4x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      17560., 17776., 17992., 18208., 18912., 19136., 19360., 19584., 20328.,
      20560., 20792., 21024., 21808., 22048., 22288., 22528., 19384., 19632.,
      19880., 20128., 20864., 21120., 21376., 21632., 22408., 22672., 22936.,
      23200., 24016., 24288., 24560., 24832., 21208., 21488., 21768., 22048.,
      22816., 23104., 23392., 23680., 24488., 24784., 25080., 25376., 26224.,
      26528., 26832., 27136., 24856., 25200., 25544., 25888., 26720., 27072.,
      27424., 27776., 28648., 29008., 29368., 29728., 30640., 31008., 31376.,
      31744., 26680., 27056., 27432., 27808., 28672., 29056., 29440., 29824.,
      30728., 31120., 31512., 31904., 32848., 33248., 33648., 34048., 28504.,
      28912., 29320., 29728., 30624., 31040., 31456., 31872., 32808., 33232.,
      33656., 34080., 35056., 35488., 35920., 36352., 32152., 32624., 33096.,
      33568., 34528., 35008., 35488., 35968., 36968., 37456., 37944., 38432.,
      39472., 39968., 40464., 40960., 33976., 34480., 34984., 35488., 36480.,
      36992., 37504., 38016., 39048., 39568., 40088., 40608., 41680., 42208.,
      42736., 43264., 35800., 36336., 36872., 37408., 38432., 38976., 39520.,
      40064., 41128., 41680., 42232., 42784., 43888., 44448., 45008., 45568.};
  const std::array<int, 4> in_shape = {{1, 6, 4, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x6x5x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {5650., 7150., 5750., 7540., 9455.,
                                         7540., 5750., 7150., 5650.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x6x5x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {974.,  1052., 1130., 1364., 1442.,
                                         1520., 1754., 1832., 1910.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x6x5x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      11050., 11300., 13975., 14300., 11230., 11500., 14720., 15080., 18445.,
      18910., 14696., 15080., 11150., 11500., 13850., 14300., 10930., 11300.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x6x5x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1834., 1948., 1978., 2104., 2122., 2260., 2554., 2728., 2698.,
      2884., 2842., 3040., 3274., 3508., 3418., 3664., 3562., 3820.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x6x5x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      21850., 22100., 22350., 22600., 27625., 27950., 28275., 28600., 22190.,
      22460., 22730., 23000., 29080., 29440., 29800., 30160., 36425., 36890.,
      37355., 37820., 29008., 29392., 29776., 30160., 21950., 22300., 22650.,
      23000., 27250., 27700., 28150., 28600., 21490., 21860., 22230., 22600.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x6x5x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3554., 3668., 3782., 3896., 3830., 3956., 4082., 4208., 4106.,
      4244., 4382., 4520., 4934., 5108., 5282., 5456., 5210., 5396.,
      5582., 5768., 5486., 5684., 5882., 6080., 6314., 6548., 6782.,
      7016., 6590., 6836., 7082., 7328., 6866., 7124., 7382., 7640.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x6x5x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      21380., 22600., 27075., 28600., 21780., 23000., 28696., 30160., 35990.,
      37820., 28696., 30160., 21780., 23000., 27075., 28600., 21380., 22600.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x6x5x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3524., 3896., 3812., 4208., 4100., 4520., 4964., 5456., 5252.,
      5768., 5540., 6080., 6404., 7016., 6692., 7328., 6980., 7640.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x6x5x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      42280., 42760., 44700., 45200., 53525., 54150., 56550., 57200., 43040.,
      43560., 45460., 46000., 56696., 57392., 59600., 60320., 71080., 71980.,
      74710., 75640., 56648., 57392., 59552., 60320., 42880., 43560., 45300.,
      46000., 53275., 54150., 56300., 57200., 42040., 42760., 44460., 45200.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x6x5x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      6832.,  7048.,  7564.,  7792.,  7384.,  7624.,  8164.,  8416.,  7936.,
      8200.,  8764.,  9040.,  9592.,  9928.,  10564., 10912., 10144., 10504.,
      11164., 11536., 10696., 11080., 11764., 12160., 12352., 12808., 13564.,
      14032., 12904., 13384., 14164., 14656., 13456., 13960., 14764., 15280.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x6x5x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      84080.,  84560.,  85040.,  85520.,  88900.,  89400.,  89900.,  90400.,
      106425., 107050., 107675., 108300., 112450., 113100., 113750., 114400.,
      85560.,  86080.,  86600.,  87120.,  90380.,  90920.,  91460.,  92000.,
      112696., 113392., 114088., 114784., 118480., 119200., 119920., 120640.,
      141260., 142160., 143060., 143960., 148490., 149420., 150350., 151280.,
      112552., 113296., 114040., 114784., 118336., 119104., 119872., 120640.,
      85080.,  85760.,  86440.,  87120.,  89900.,  90600.,  91300.,  92000.,
      105675., 106550., 107425., 108300., 111700., 112600., 113500., 114400.,
      83360.,  84080.,  84800.,  85520.,  88180.,  88920.,  89660.,  90400.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x6x5x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      13448., 13664., 13880., 14096., 14900., 15128., 15356., 15584., 14528.,
      14768., 15008., 15248., 16076., 16328., 16580., 16832., 15608., 15872.,
      16136., 16400., 17252., 17528., 17804., 18080., 18848., 19184., 19520.,
      19856., 20780., 21128., 21476., 21824., 19928., 20288., 20648., 21008.,
      21956., 22328., 22700., 23072., 21008., 21392., 21776., 22160., 23132.,
      23528., 23924., 24320., 24248., 24704., 25160., 25616., 26660., 27128.,
      27596., 28064., 25328., 25808., 26288., 26768., 27836., 28328., 28820.,
      29312., 26408., 26912., 27416., 27920., 29012., 29528., 30044., 30560.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x6x5x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      83140.,  85520.,  87940.,  90400.,  105325., 108300., 111325., 114400.,
      84740.,  87120.,  89540.,  92000.,  111928., 114784., 117688., 120640.,
      140390., 143960., 147590., 151280., 111928., 114784., 117688., 120640.,
      84740.,  87120.,  89540.,  92000.,  105325., 108300., 111325., 114400.,
      83140.,  85520.,  87940.,  90400.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x6x5x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      13388., 14096., 14828., 15584., 14492., 15248., 16028., 16832., 15596.,
      16400., 17228., 18080., 18908., 19856., 20828., 21824., 20012., 21008.,
      22028., 23072., 21116., 22160., 23228., 24320., 24428., 25616., 26828.,
      28064., 25532., 26768., 28028., 29312., 26636., 27920., 29228., 30560.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x6x5x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      165340., 166280., 170080., 171040., 174900., 175880., 179800., 180800.,
      209425., 210650., 215350., 216600., 221375., 222650., 227500., 228800.,
      168460., 169480., 173200., 174240., 178020., 179080., 182920., 184000.,
      222488., 223856., 228176., 229568., 233960., 235376., 239840., 241280.,
      279010., 280780., 286120., 287920., 293350., 295180., 300700., 302560.,
      222392., 223856., 228080., 229568., 233864., 235376., 239744., 241280.,
      168140., 169480., 172880., 174240., 177700., 179080., 182600., 184000.,
      208925., 210650., 214850., 216600., 220875., 222650., 227000., 228800.,
      164860., 166280., 169600., 171040., 174420., 175880., 179320., 180800.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x6x5x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      26356., 26776., 27760., 28192., 29212., 29656., 30712., 31168., 28516.,
      28984., 30016., 30496., 31564., 32056., 33160., 33664., 30676., 31192.,
      32272., 32800., 33916., 34456., 35608., 36160., 37156., 37816., 39040.,
      39712., 40972., 41656., 42952., 43648., 39316., 40024., 41296., 42016.,
      43324., 44056., 45400., 46144., 41476., 42232., 43552., 44320., 45676.,
      46456., 47848., 48640., 47956., 48856., 50320., 51232., 52732., 53656.,
      55192., 56128., 50116., 51064., 52576., 53536., 55084., 56056., 57640.,
      58624., 52276., 53272., 54832., 55840., 57436., 58456., 60088., 61120.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x6x5x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      329740., 330680., 331620., 332560., 339200., 340160., 341120., 342080.,
      348820., 349800., 350780., 351760., 358600., 359600., 360600., 361600.,
      417625., 418850., 420075., 421300., 429450., 430700., 431950., 433200.,
      441475., 442750., 444025., 445300., 453700., 455000., 456300., 457600.,
      335900., 336920., 337940., 338960., 345360., 346400., 347440., 348480.,
      354980., 356040., 357100., 358160., 364760., 365840., 366920., 368000.,
      443608., 444976., 446344., 447712., 454960., 456352., 457744., 459136.,
      466504., 467920., 469336., 470752., 478240., 479680., 481120., 482560.,
      556250., 558020., 559790., 561560., 570440., 572240., 574040., 575840.,
      584870., 586700., 588530., 590360., 599540., 601400., 603260., 605120.,
      443320., 444784., 446248., 447712., 454672., 456160., 457648., 459136.,
      466216., 467728., 469240., 470752., 477952., 479488., 481024., 482560.,
      334940., 336280., 337620., 338960., 344400., 345760., 347120., 348480.,
      354020., 355400., 356780., 358160., 363800., 365200., 366600., 368000.,
      416125., 417850., 419575., 421300., 427950., 429700., 431450., 433200.,
      439975., 441750., 443525., 445300., 452200., 454000., 455800., 457600.,
      328300., 329720., 331140., 332560., 337760., 339200., 340640., 342080.,
      347380., 348840., 350300., 351760., 357160., 358640., 360120., 361600.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x6x5x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      52292.,  52712.,  53132.,  53552.,  55088.,  55520.,  55952.,  56384.,
      57980.,  58424.,  58868.,  59312.,  60968.,  61424.,  61880.,  62336.,
      56564.,  57032.,  57500.,  57968.,  59552.,  60032.,  60512.,  60992.,
      62636.,  63128.,  63620.,  64112.,  65816.,  66320.,  66824.,  67328.,
      60836.,  61352.,  61868.,  62384.,  64016.,  64544.,  65072.,  65600.,
      67292.,  67832.,  68372.,  68912.,  70664.,  71216.,  71768.,  72320.,
      73652.,  74312.,  74972.,  75632.,  77408.,  78080.,  78752.,  79424.,
      81260.,  81944.,  82628.,  83312.,  85208.,  85904.,  86600.,  87296.,
      77924.,  78632.,  79340.,  80048.,  81872.,  82592.,  83312.,  84032.,
      85916.,  86648.,  87380.,  88112.,  90056.,  90800.,  91544.,  92288.,
      82196.,  82952.,  83708.,  84464.,  86336.,  87104.,  87872.,  88640.,
      90572.,  91352.,  92132.,  92912.,  94904.,  95696.,  96488.,  97280.,
      95012.,  95912.,  96812.,  97712.,  99728.,  100640., 101552., 102464.,
      104540., 105464., 106388., 107312., 109448., 110384., 111320., 112256.,
      99284.,  100232., 101180., 102128., 104192., 105152., 106112., 107072.,
      109196., 110168., 111140., 112112., 114296., 115280., 116264., 117248.,
      103556., 104552., 105548., 106544., 108656., 109664., 110672., 111680.,
      113852., 114872., 115892., 116912., 119144., 120176., 121208., 122240.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x6x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {10100., 12245., 10250., 13470., 16206.,
                                         13470., 10250., 12245., 10100.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x6x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {2064., 2200., 2336., 2880., 3016.,
                                         3152., 3696., 3832., 3968.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x6x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      19825., 20200., 24025., 24490., 20100., 20500., 26400., 26940., 31746.,
      32412., 26370., 26940., 19975., 20500., 23845., 24490., 19650., 20200.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x6x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3944., 4128., 4200., 4400., 4456., 4672., 5480., 5760., 5736.,
      6032., 5992., 6304., 7016., 7392., 7272., 7664., 7528., 7936.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x6x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      39275., 39650., 40025., 40400., 47585., 48050., 48515., 48980., 39800.,
      40200., 40600., 41000., 52260., 52800., 53340., 53880., 62826., 63492.,
      64158., 64824., 52170., 52740., 53310., 53880., 39425., 39950., 40475.,
      41000., 47045., 47690., 48335., 48980., 38750., 39300., 39850., 40400.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x6x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      7704.,  7888.,  8072.,  8256.,  8200.,  8400.,  8600.,  8800.,  8696.,
      8912.,  9128.,  9344.,  10680., 10960., 11240., 11520., 11176., 11472.,
      11768., 12064., 11672., 11984., 12296., 12608., 13656., 14032., 14408.,
      14784., 14152., 14544., 14936., 15328., 14648., 15056., 15464., 15872.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x6x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      38575., 40400., 46790., 48980., 39175., 41000., 51690., 53880., 62196.,
      64824., 51690., 53880., 39175., 41000., 46790., 48980., 38575., 40400.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x6x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      7632.,  8256.,  8144.,  8800.,  8656.,  9344.,  10704., 11520., 11216.,
      12064., 11728., 12608., 13776., 14784., 14288., 15328., 14800., 15872.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x6x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      76425.,  77150.,  80050.,  80800.,  92680.,  93580.,  97030.,  97960.,
      77575.,  78350.,  81200.,  82000.,  102330., 103380., 106680., 107760.,
      123096., 124392., 128316., 129648., 102270., 103380., 106620., 107760.,
      77325.,  78350.,  80950.,  82000.,  92320.,  93580.,  96670.,  97960.,
      76075.,  77150.,  79700.,  80800.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x6x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      14912., 15264., 16144., 16512., 15904., 16288., 17200., 17600., 16896.,
      17312., 18256., 18688., 20864., 21408., 22480., 23040., 21856., 22432.,
      23536., 24128., 22848., 23456., 24592., 25216., 26816., 27552., 28816.,
      29568., 27808., 28576., 29872., 30656., 28800., 29600., 30928., 31744.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x6x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      152125., 152850., 153575., 154300., 159350., 160100., 160850., 161600.,
      184460., 185360., 186260., 187160., 193130., 194060., 194990., 195920.,
      154375., 155150., 155925., 156700., 161600., 162400., 163200., 164000.,
      203610., 204660., 205710., 206760., 212280., 213360., 214440., 215520.,
      244896., 246192., 247488., 248784., 255300., 256632., 257964., 259296.,
      203430., 204540., 205650., 206760., 212100., 213240., 214380., 215520.,
      153625., 154650., 155675., 156700., 160850., 161900., 162950., 164000.,
      183380., 184640., 185900., 187160., 192050., 193340., 194630., 195920.,
      151075., 152150., 153225., 154300., 158300., 159400., 160500., 161600.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x6x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      29472., 29824., 30176., 30528., 31920., 32288., 32656., 33024., 31424.,
      31808., 32192., 32576., 34000., 34400., 34800., 35200., 33376., 33792.,
      34208., 34624., 36080., 36512., 36944., 37376., 41184., 41728., 42272.,
      42816., 44400., 44960., 45520., 46080., 43136., 43712., 44288., 44864.,
      46480., 47072., 47664., 48256., 45088., 45696., 46304., 46912., 48560.,
      49184., 49808., 50432., 52896., 53632., 54368., 55104., 56880., 57632.,
      58384., 59136., 54848., 55616., 56384., 57152., 58960., 59744., 60528.,
      61312., 56800., 57600., 58400., 59200., 61040., 61856., 62672., 63488.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x6x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      150725., 154300., 157925., 161600., 182870., 187160., 191510., 195920.,
      153125., 156700., 160325., 164000., 202470., 206760., 211110., 215520.,
      243636., 248784., 254004., 259296., 202470., 206760., 211110., 215520.,
      153125., 156700., 160325., 164000., 182870., 187160., 191510., 195920.,
      150725., 154300., 157925., 161600.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x6x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      29328., 30528., 31760., 33024., 31312., 32576., 33872., 35200., 33296.,
      34624., 35984., 37376., 41232., 42816., 44432., 46080., 43216., 44864.,
      46544., 48256., 45200., 46912., 48656., 50432., 53136., 55104., 57104.,
      59136., 55120., 57152., 59216., 61312., 57104., 59200., 61328., 63488.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x6x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      300025., 301450., 307150., 308600., 314375., 315850., 321700., 323200.,
      363970., 365740., 372520., 374320., 381190., 383020., 389980., 391840.,
      304725., 306250., 311850., 313400., 319075., 320650., 326400., 328000.,
      402870., 404940., 411420., 413520., 420090., 422220., 428880., 431040.,
      484716., 487272., 494976., 497568., 505380., 508008., 515928., 518592.,
      402750., 404940., 411300., 413520., 419970., 422220., 428760., 431040.,
      304225., 306250., 311350., 313400., 318575., 320650., 325900., 328000.,
      363250., 365740., 371800., 374320., 380470., 383020., 389260., 391840.,
      299325., 301450., 306450., 308600., 313675., 315850., 321000., 323200.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x6x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      57968.,  58656.,  60352.,  61056.,  62800.,  63520.,  65312.,  66048.,
      61872.,  62624.,  64384.,  65152.,  66960.,  67744.,  69600.,  70400.,
      65776.,  66592.,  68416.,  69248.,  71120.,  71968.,  73888.,  74752.,
      81392.,  82464.,  84544.,  85632.,  87760.,  88864.,  91040.,  92160.,
      85296.,  86432.,  88576.,  89728.,  91920.,  93088.,  95328.,  96512.,
      89200.,  90400.,  92608.,  93824.,  96080.,  97312.,  99616.,  100864.,
      104816., 106272., 108736., 110208., 112720., 114208., 116768., 118272.,
      108720., 110240., 112768., 114304., 116880., 118432., 121056., 122624.,
      112624., 114208., 116800., 118400., 121040., 122656., 125344., 126976.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME1x6x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      598625.,  600050.,  601475.,  602900.,  612850.,  614300.,  615750.,
      617200.,  627275.,  628750.,  630225.,  631700.,  641900.,  643400.,
      644900.,  646400.,  726170.,  727940.,  729710.,  731480.,  743240.,
      745040.,  746840.,  748640.,  760550.,  762380.,  764210.,  766040.,
      778100.,  779960.,  781820.,  783680.,  607925.,  609450.,  610975.,
      612500.,  622150.,  623700.,  625250.,  626800.,  636575.,  638150.,
      639725.,  641300.,  651200.,  652800.,  654400.,  656000.,  803670.,
      805740.,  807810.,  809880.,  820740.,  822840.,  824940.,  827040.,
      838050.,  840180.,  842310.,  844440.,  855600.,  857760.,  859920.,
      862080.,  966876.,  969432.,  971988.,  974544.,  987360.,  989952.,
      992544.,  995136.,  1008132., 1010760., 1013388., 1016016., 1029192.,
      1031856., 1034520., 1037184., 803310.,  805500.,  807690.,  809880.,
      820380.,  822600.,  824820.,  827040.,  837690.,  839940.,  842190.,
      844440.,  855240.,  857520.,  859800.,  862080.,  606425.,  608450.,
      610475.,  612500.,  620650.,  622700.,  624750.,  626800.,  635075.,
      637150.,  639225.,  641300.,  649700.,  651800.,  653900.,  656000.,
      724010.,  726500.,  728990.,  731480.,  741080.,  743600.,  746120.,
      748640.,  758390.,  760940.,  763490.,  766040.,  775940.,  778520.,
      781100.,  783680.,  596525.,  598650.,  600775.,  602900.,  610750.,
      612900.,  615050.,  617200.,  625175.,  627350.,  629525.,  631700.,
      639800.,  642000.,  644200.,  646400.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID1x6x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      115248., 115936., 116624., 117312., 120000., 120704., 121408., 122112.,
      124880., 125600., 126320., 127040., 129888., 130624., 131360., 132096.,
      122992., 123744., 124496., 125248., 128000., 128768., 129536., 130304.,
      133136., 133920., 134704., 135488., 138400., 139200., 140000., 140800.,
      130736., 131552., 132368., 133184., 136000., 136832., 137664., 138496.,
      141392., 142240., 143088., 143936., 146912., 147776., 148640., 149504.,
      161712., 162784., 163856., 164928., 168000., 169088., 170176., 171264.,
      174416., 175520., 176624., 177728., 180960., 182080., 183200., 184320.,
      169456., 170592., 171728., 172864., 176000., 177152., 178304., 179456.,
      182672., 183840., 185008., 186176., 189472., 190656., 191840., 193024.,
      177200., 178400., 179600., 180800., 184000., 185216., 186432., 187648.,
      190928., 192160., 193392., 194624., 197984., 199232., 200480., 201728.,
      208176., 209632., 211088., 212544., 216000., 217472., 218944., 220416.,
      223952., 225440., 226928., 228416., 232032., 233536., 235040., 236544.,
      215920., 217440., 218960., 220480., 224000., 225536., 227072., 228608.,
      232208., 233760., 235312., 236864., 240544., 242112., 243680., 245248.,
      223664., 225248., 226832., 228416., 232000., 233600., 235200., 236800.,
      240464., 242080., 243696., 245312., 249056., 250688., 252320., 253952.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x4x4x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {20952., 28038., 21060., 28488., 38024.,
                                         28488., 21060., 28038., 20952.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x4x4x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {2060., 2138., 2216., 2372., 2450.,
                                         2528., 2684., 2762., 2840.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x4x4x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      41310., 41904., 55266., 56076., 41499., 42120., 56112., 56976., 74872.,
      76048., 56076., 56976., 41418., 42120., 55122., 56076., 41175., 41904.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x4x4x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3886., 4120., 4030., 4276., 4174., 4432., 4462., 4744., 4606.,
      4900., 4750., 5056., 5038., 5368., 5182., 5524., 5326., 5680.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x4x4x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      82026.,  82620.,  83214.,  83808.,  109722., 110532., 111342., 112152.,
      82377.,  82998.,  83619.,  84240.,  111360., 112224., 113088., 113952.,
      148568., 149744., 150920., 152096., 111252., 112152., 113052., 113952.,
      82134.,  82836.,  83538.,  84240.,  109290., 110244., 111198., 112152.,
      81621.,  82350.,  83079.,  83808.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x4x4x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      7538.,  7772.,  8006.,  8240.,  7814.,  8060.,  8306.,  8552.,  8090.,
      8348.,  8606.,  8864.,  8642.,  8924.,  9206.,  9488.,  8918.,  9212.,
      9506.,  9800.,  9194.,  9500.,  9806.,  10112., 9746.,  10076., 10406.,
      10736., 10022., 10364., 10706., 11048., 10298., 10652., 11006., 11360.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x4x4x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      81189.,  83808.,  108660., 112152., 81621.,  84240.,
      110460., 113952., 147440., 152096., 110460., 113952.,
      81621.,  84240.,  108660., 112152., 81189.,  83808.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x4x4x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      7628., 8240., 7916.,  8552., 8204.,  8864.,  8780.,  9488.,  9068.,
      9800., 9356., 10112., 9932., 10736., 10220., 11048., 10508., 11360.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x4x4x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      161217., 162378., 166428., 167616., 215736., 217320., 222684., 224304.,
      162027., 163242., 167238., 168480., 219228., 220920., 226176., 227904.,
      292576., 294880., 301840., 304192., 219156., 220920., 226104., 227904.,
      161865., 163242., 167076., 168480., 215448., 217320., 222396., 224304.,
      160947., 162378., 166158., 167616.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x4x4x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      14800., 15256., 16012., 16480., 15352., 15832., 16612., 17104., 15904.,
      16408., 17212., 17728., 17008., 17560., 18412., 18976., 17560., 18136.,
      19012., 19600., 18112., 18712., 19612., 20224., 19216., 19864., 20812.,
      21472., 19768., 20440., 21412., 22096., 20320., 21016., 22012., 22720.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x4x4x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      321273., 322434., 323595., 324756., 331668., 332856., 334044., 335232.,
      429888., 431472., 433056., 434640., 443748., 445368., 446988., 448608.,
      322839., 324054., 325269., 326484., 333234., 334476., 335718., 336960.,
      436764., 438456., 440148., 441840., 450624., 452352., 454080., 455808.,
      582848., 585152., 587456., 589760., 601328., 603680., 606032., 608384.,
      436548., 438312., 440076., 441840., 450408., 452208., 454008., 455808.,
      322353., 323730., 325107., 326484., 332748., 334152., 335556., 336960.,
      429024., 430896., 432768., 434640., 442884., 444792., 446700., 448608.,
      320463., 321894., 323325., 324756., 330858., 332316., 333774., 335232.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x4x4x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      29144., 29600., 30056., 30512., 31556., 32024., 32492., 32960., 30224.,
      30704., 31184., 31664., 32732., 33224., 33716., 34208., 31304., 31808.,
      32312., 32816., 33908., 34424., 34940., 35456., 33464., 34016., 34568.,
      35120., 36260., 36824., 37388., 37952., 34544., 35120., 35696., 36272.,
      37436., 38024., 38612., 39200., 35624., 36224., 36824., 37424., 38612.,
      39224., 39836., 40448., 37784., 38432., 39080., 39728., 40964., 41624.,
      42284., 42944., 38864., 39536., 40208., 40880., 42140., 42824., 43508.,
      44192., 39944., 40640., 41336., 42032., 43316., 44024., 44732., 45440.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x4x4x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      319599., 324756., 329967., 335232., 427764., 434640., 441588., 448608.,
      321327., 326484., 331695., 336960., 434964., 441840., 448788., 455808.,
      580592., 589760., 599024., 608384., 434964., 441840., 448788., 455808.,
      321327., 326484., 331695., 336960., 427764., 434640., 441588., 448608.,
      319599., 324756., 329967., 335232.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x4x4x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      29324., 30512., 31724., 32960., 30428., 31664., 32924., 34208., 31532.,
      32816., 34124., 35456., 33740., 35120., 36524., 37952., 34844., 36272.,
      37724., 39200., 35948., 37424., 38924., 40448., 38156., 39728., 41324.,
      42944., 39260., 40880., 42524., 44192., 40364., 42032., 43724., 45440.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x4x4x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      636903.,  639198.,  647190.,  649512.,  657585.,  659934.,  668088.,
      670464.,  852396.,  855528.,  866112.,  869280.,  879972.,  883176.,
      893976.,  897216.,  640251.,  642654.,  650538.,  652968.,  660933.,
      663390.,  671436.,  673920.,  866580.,  869928.,  880296.,  883680.,
      894156.,  897576.,  908160.,  911616.,  1156624., 1161184., 1174912.,
      1179520., 1193392., 1198048., 1212064., 1216768., 866436.,  869928.,
      880152.,  883680.,  894012.,  897576.,  908016.,  911616.,  639927.,
      642654.,  650214.,  652968.,  660609.,  663390.,  671112.,  673920.,
      851820.,  855528.,  865536.,  869280.,  879396.,  883176.,  893400.,
      897216.,  636363.,  639198.,  646650.,  649512.,  657045.,  659934.,
      667548.,  670464.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x4x4x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      57748., 58648., 60112., 61024., 62524., 63448., 64984., 65920., 59908.,
      60856., 62368., 63328., 64876., 65848., 67432., 68416., 62068., 63064.,
      64624., 65632., 67228., 68248., 69880., 70912., 66388., 67480., 69136.,
      70240., 71932., 73048., 74776., 75904., 68548., 69688., 71392., 72544.,
      74284., 75448., 77224., 78400., 70708., 71896., 73648., 74848., 76636.,
      77848., 79672., 80896., 75028., 76312., 78160., 79456., 81340., 82648.,
      84568., 85888., 77188., 78520., 80416., 81760., 83692., 85048., 87016.,
      88384., 79348., 80728., 82672., 84064., 86044., 87448., 89464., 90880.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x4x4x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1271511., 1273806., 1276101., 1278396., 1292058., 1294380., 1296702.,
      1299024., 1312821., 1315170., 1317519., 1319868., 1333800., 1336176.,
      1338552., 1340928., 1701660., 1704792., 1707924., 1711056., 1729056.,
      1732224., 1735392., 1738560., 1756740., 1759944., 1763148., 1766352.,
      1784712., 1787952., 1791192., 1794432., 1278099., 1280502., 1282905.,
      1285308., 1298646., 1301076., 1303506., 1305936., 1319409., 1321866.,
      1324323., 1326780., 1340388., 1342872., 1345356., 1347840., 1729812.,
      1733160., 1736508., 1739856., 1757208., 1760592., 1763976., 1767360.,
      1784892., 1788312., 1791732., 1795152., 1812864., 1816320., 1819776.,
      1823232., 2308688., 2313248., 2317808., 2322368., 2345216., 2349824.,
      2354432., 2359040., 2382128., 2386784., 2391440., 2396096., 2419424.,
      2424128., 2428832., 2433536., 1729380., 1732872., 1736364., 1739856.,
      1756776., 1760304., 1763832., 1767360., 1784460., 1788024., 1791588.,
      1795152., 1812432., 1816032., 1819632., 1823232., 1277127., 1279854.,
      1282581., 1285308., 1297674., 1300428., 1303182., 1305936., 1318437.,
      1321218., 1323999., 1326780., 1339416., 1342224., 1345032., 1347840.,
      1699932., 1703640., 1707348., 1711056., 1727328., 1731072., 1734816.,
      1738560., 1755012., 1758792., 1762572., 1766352., 1782984., 1786800.,
      1790616., 1794432., 1269891., 1272726., 1275561., 1278396., 1290438.,
      1293300., 1296162., 1299024., 1311201., 1314090., 1316979., 1319868.,
      1332180., 1335096., 1338012., 1340928.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x4x4x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      114596., 115496., 116396., 117296., 119312., 120224., 121136., 122048.,
      124124., 125048., 125972., 126896., 129032., 129968., 130904., 131840.,
      118868., 119816., 120764., 121712., 123776., 124736., 125696., 126656.,
      128780., 129752., 130724., 131696., 133880., 134864., 135848., 136832.,
      123140., 124136., 125132., 126128., 128240., 129248., 130256., 131264.,
      133436., 134456., 135476., 136496., 138728., 139760., 140792., 141824.,
      131684., 132776., 133868., 134960., 137168., 138272., 139376., 140480.,
      142748., 143864., 144980., 146096., 148424., 149552., 150680., 151808.,
      135956., 137096., 138236., 139376., 141632., 142784., 143936., 145088.,
      147404., 148568., 149732., 150896., 153272., 154448., 155624., 156800.,
      140228., 141416., 142604., 143792., 146096., 147296., 148496., 149696.,
      152060., 153272., 154484., 155696., 158120., 159344., 160568., 161792.,
      148772., 150056., 151340., 152624., 155024., 156320., 157616., 158912.,
      161372., 162680., 163988., 165296., 167816., 169136., 170456., 171776.,
      153044., 154376., 155708., 157040., 159488., 160832., 162176., 163520.,
      166028., 167384., 168740., 170096., 172664., 174032., 175400., 176768.,
      157316., 158696., 160076., 161456., 163952., 165344., 166736., 168128.,
      170684., 172088., 173492., 174896., 177512., 178928., 180344., 181760.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x4x5x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {43410., 54420., 43590., 59000., 73810.,
                                         59000., 43590., 54420., 43410.};
  const std::array<int, 4> in_shape = {{3, 4, 5, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x4x5x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {5709., 5880., 6051., 6564., 6735.,
                                         6906., 7419., 7590., 7761.};
  const std::array<int, 4> in_shape = {{3, 4, 5, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x4x5x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      85830.,  86820.,  107580., 108840., 86154.,  87180.,
      116560., 118000., 145790., 147620., 116512., 118000.,
      86010.,  87180.,  107355., 108840., 85614.,  86820.};
  const std::array<int, 4> in_shape = {{3, 4, 5, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x4x5x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      10977., 11418., 11301., 11760., 11625., 12102., 12597., 13128., 12921.,
      13470., 13245., 13812., 14217., 14838., 14541., 15180., 14865., 15522.};
  const std::array<int, 4> in_shape = {{3, 4, 5, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x4x5x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      170670., 171660., 172650., 173640., 213900., 215160., 216420., 217680.,
      171282., 172308., 173334., 174360., 231680., 233120., 234560., 236000.,
      289750., 291580., 293410., 295240., 231536., 233024., 234512., 236000.,
      170850., 172020., 173190., 174360., 213225., 214710., 216195., 217680.,
      170022., 171228., 172434., 173640.};
  const std::array<int, 4> in_shape = {{3, 4, 5, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x4x5x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      21513., 21954., 22395., 22836., 22143., 22602., 23061., 23520., 22773.,
      23250., 23727., 24204., 24663., 25194., 25725., 26256., 25293., 25842.,
      26391., 26940., 25923., 26490., 27057., 27624., 27813., 28434., 29055.,
      29676., 28443., 29082., 29721., 30360., 29073., 29730., 30387., 31044.};
  const std::array<int, 4> in_shape = {{3, 4, 5, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x4x5x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      169284., 173640., 212235., 217680., 170004., 174360.,
      230192., 236000., 287980., 295240., 230192., 236000.,
      170004., 174360., 212235., 217680., 169284., 173640.};
  const std::array<int, 4> in_shape = {{3, 4, 5, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x4x5x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      21630., 22836., 22278., 23520., 22926., 24204., 24870., 26256., 25518.,
      26940., 26166., 27624., 28110., 29676., 28758., 30360., 29406., 31044.};
  const std::array<int, 4> in_shape = {{3, 4, 5, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x4x5x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      336624., 338568., 345300., 347280., 421995., 424470., 432840., 435360.,
      337992., 340008., 346668., 348720., 457552., 460384., 469120., 472000.,
      572360., 575960., 586820., 590480., 457456., 460384., 469024., 472000.,
      337704., 340008., 346380., 348720., 421545., 424470., 432390., 435360.,
      336192., 338568., 344868., 347280.};
  const std::array<int, 4> in_shape = {{3, 4, 5, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x4x5x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      42396., 43260., 44790., 45672., 43656., 44556., 46122., 47040., 44916.,
      45852., 47454., 48408., 48696., 49740., 51450., 52512., 49956., 51036.,
      52782., 53880., 51216., 52332., 54114., 55248., 54996., 56220., 58110.,
      59352., 56256., 57516., 59442., 60720., 57516., 58812., 60774., 62088.};
  const std::array<int, 4> in_shape = {{3, 4, 5, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x4x5x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      671304.,  673248.,  675192.,  677136.,  688620.,  690600.,  692580.,
      694560.,  841515.,  843990.,  846465.,  848940.,  863160.,  865680.,
      868200.,  870720.,  673968.,  675984.,  678000.,  680016.,  691284.,
      693336.,  695388.,  697440.,  912272.,  915104.,  917936.,  920768.,
      935360.,  938240.,  941120.,  944000.,  1141120., 1144720., 1148320.,
      1151920., 1169980., 1173640., 1177300., 1180960., 911984.,  914912.,
      917840.,  920768.,  935072.,  938048.,  941024.,  944000.,  673104.,
      675408.,  677712.,  680016.,  690420.,  692760.,  695100.,  697440.,
      840165.,  843090.,  846015.,  848940.,  861810.,  864780.,  867750.,
      870720.,  670008.,  672384.,  674760.,  677136.,  687324.,  689736.,
      692148.,  694560.};
  const std::array<int, 4> in_shape = {{3, 4, 5, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x4x5x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      83928.,  84792.,  85656.,  86520.,  88698.,  89580.,  90462.,  91344.,
      86412.,  87312.,  88212.,  89112.,  91326.,  92244.,  93162.,  94080.,
      88896.,  89832.,  90768.,  91704.,  93954.,  94908.,  95862.,  96816.,
      96348.,  97392.,  98436.,  99480.,  101838., 102900., 103962., 105024.,
      98832.,  99912.,  100992., 102072., 104466., 105564., 106662., 107760.,
      101316., 102432., 103548., 104664., 107094., 108228., 109362., 110496.,
      108768., 109992., 111216., 112440., 114978., 116220., 117462., 118704.,
      111252., 112512., 113772., 115032., 117606., 118884., 120162., 121440.,
      113736., 115032., 116328., 117624., 120234., 121548., 122862., 124176.};
  const std::array<int, 4> in_shape = {{3, 4, 5, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x4x5x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      668532.,  677136.,  685812., 694560., 838185.,  848940.,
      859785.,  870720.,  671412., 680016., 688692.,  697440.,
      909296.,  920768.,  932336., 944000., 1137580., 1151920.,
      1166380., 1180960., 909296., 920768., 932336.,  944000.,
      671412.,  680016.,  688692., 697440., 838185.,  848940.,
      859785.,  870720.,  668532., 677136., 685812.,  694560.};
  const std::array<int, 4> in_shape = {{3, 4, 5, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x4x5x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      84162.,  86520.,  88914.,  91344.,  86682.,  89112.,  91578.,  94080.,
      89202.,  91704.,  94242.,  96816.,  96762.,  99480.,  102234., 105024.,
      99282.,  102072., 104898., 107760., 101802., 104664., 107562., 110496.,
      109362., 112440., 115554., 118704., 111882., 115032., 118218., 121440.,
      114402., 117624., 120882., 124176.};
  const std::array<int, 4> in_shape = {{3, 4, 5, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x4x5x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1333212., 1337064., 1350384., 1354272., 1367700., 1371624., 1385160.,
      1389120., 1671465., 1676370., 1692930., 1697880., 1714575., 1719570.,
      1736400., 1741440., 1338828., 1342824., 1356000., 1360032., 1373316.,
      1377384., 1390776., 1394880., 1812976., 1818592., 1835872., 1841536.,
      1858960., 1864672., 1882240., 1888000., 2268020., 2275160., 2296640.,
      2303840., 2325500., 2332760., 2354600., 2361920., 1812784., 1818592.,
      1835680., 1841536., 1858768., 1864672., 1882048., 1888000., 1338252.,
      1342824., 1355424., 1360032., 1372740., 1377384., 1390200., 1394880.,
      1670565., 1676370., 1692030., 1697880., 1713675., 1719570., 1735500.,
      1741440., 1332348., 1337064., 1349520., 1354272., 1366836., 1371624.,
      1384296., 1389120.};
  const std::array<int, 4> in_shape = {{3, 4, 5, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x4x5x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      166614., 168324., 171312., 173040., 176082., 177828., 180924., 182688.,
      171582., 173364., 176424., 178224., 181338., 183156., 186324., 188160.,
      176550., 178404., 181536., 183408., 186594., 188484., 191724., 193632.,
      191454., 193524., 196872., 198960., 202362., 204468., 207924., 210048.,
      196422., 198564., 201984., 204144., 207618., 209796., 213324., 215520.,
      201390., 203604., 207096., 209328., 212874., 215124., 218724., 220992.,
      216294., 218724., 222432., 224880., 228642., 231108., 234924., 237408.,
      221262., 223764., 227544., 230064., 233898., 236436., 240324., 242880.,
      226230., 228804., 232656., 235248., 239154., 241764., 245724., 248352.};
  const std::array<int, 4> in_shape = {{3, 4, 5, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x4x5x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2662572., 2666424., 2670276., 2674128., 2696880., 2700768., 2704656.,
      2708544., 2731476., 2735400., 2739324., 2743248., 2766360., 2770320.,
      2774280., 2778240., 3338025., 3342930., 3347835., 3352740., 3380910.,
      3385860., 3390810., 3395760., 3424155., 3429150., 3434145., 3439140.,
      3467760., 3472800., 3477840., 3482880., 2673660., 2677656., 2681652.,
      2685648., 2707968., 2712000., 2716032., 2720064., 2742564., 2746632.,
      2750700., 2754768., 2777448., 2781552., 2785656., 2789760., 3620336.,
      3625952., 3631568., 3637184., 3666080., 3671744., 3677408., 3683072.,
      3712208., 3717920., 3723632., 3729344., 3758720., 3764480., 3770240.,
      3776000., 4528900., 4536040., 4543180., 4550320., 4586080., 4593280.,
      4600480., 4607680., 4643740., 4651000., 4658260., 4665520., 4701880.,
      4709200., 4716520., 4723840., 3619760., 3625568., 3631376., 3637184.,
      3665504., 3671360., 3677216., 3683072., 3711632., 3717536., 3723440.,
      3729344., 3758144., 3764096., 3770048., 3776000., 2671932., 2676504.,
      2681076., 2685648., 2706240., 2710848., 2715456., 2720064., 2740836.,
      2745480., 2750124., 2754768., 2775720., 2780400., 2785080., 2789760.,
      3335325., 3341130., 3346935., 3352740., 3378210., 3384060., 3389910.,
      3395760., 3421455., 3427350., 3433245., 3439140., 3465060., 3471000.,
      3476940., 3482880., 2659980., 2664696., 2669412., 2674128., 2694288.,
      2699040., 2703792., 2708544., 2728884., 2733672., 2738460., 2743248.,
      2763768., 2768592., 2773416., 2778240.};
  const std::array<int, 4> in_shape = {{3, 4, 5, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x4x5x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      331518., 333228., 334938., 336648., 340896., 342624., 344352., 346080.,
      350418., 352164., 353910., 355656., 360084., 361848., 363612., 365376.,
      341382., 343164., 344946., 346728., 351048., 352848., 354648., 356448.,
      360858., 362676., 364494., 366312., 370812., 372648., 374484., 376320.,
      351246., 353100., 354954., 356808., 361200., 363072., 364944., 366816.,
      371298., 373188., 375078., 376968., 381540., 383448., 385356., 387264.,
      380838., 382908., 384978., 387048., 391656., 393744., 395832., 397920.,
      402618., 404724., 406830., 408936., 413724., 415848., 417972., 420096.,
      390702., 392844., 394986., 397128., 401808., 403968., 406128., 408288.,
      413058., 415236., 417414., 419592., 424452., 426648., 428844., 431040.,
      400566., 402780., 404994., 407208., 411960., 414192., 416424., 418656.,
      423498., 425748., 427998., 430248., 435180., 437448., 439716., 441984.,
      430158., 432588., 435018., 437448., 442416., 444864., 447312., 449760.,
      454818., 457284., 459750., 462216., 467364., 469848., 472332., 474816.,
      440022., 442524., 445026., 447528., 452568., 455088., 457608., 460128.,
      465258., 467796., 470334., 472872., 478092., 480648., 483204., 485760.,
      449886., 452460., 455034., 457608., 462720., 465312., 467904., 470496.,
      475698., 478308., 480918., 483528., 488820., 491448., 494076., 496704.};
  const std::array<int, 4> in_shape = {{3, 4, 5, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x4x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {77850.,  93645.,  78120.,
                                         105780., 127020., 105780.,
                                         78120.,  93645.,  77850.};
  const std::array<int, 4> in_shape = {{3, 4, 6, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x4x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {12096., 12396., 12696., 13896., 14196.,
                                         14496., 15696., 15996., 16296.};
  const std::array<int, 4> in_shape = {{3, 4, 6, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x4x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      154215., 155700., 185481., 187290., 154710., 156240.,
      209400., 211560., 251412., 254040., 209340., 211560.,
      154485., 156240., 185157., 187290., 153900., 155700.};
  const std::array<int, 4> in_shape = {{3, 4, 6, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x4x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      23484., 24192., 24060., 24792., 24636., 25392., 26940., 27792., 27516.,
      28392., 28092., 28992., 30396., 31392., 30972., 31992., 31548., 32592.};
  const std::array<int, 4> in_shape = {{3, 4, 6, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x4x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      306945., 308430., 309915., 311400., 369153., 370962., 372771., 374580.,
      307890., 309420., 310950., 312480., 416640., 418800., 420960., 423120.,
      500196., 502824., 505452., 508080., 416460., 418680., 420900., 423120.,
      307215., 308970., 310725., 312480., 368181., 370314., 372447., 374580.,
      306000., 307800., 309600., 311400.};
  const std::array<int, 4> in_shape = {{3, 4, 6, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x4x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      46260., 46968., 47676., 48384., 47388., 48120., 48852., 49584., 48516.,
      49272., 50028., 50784., 53028., 53880., 54732., 55584., 54156., 55032.,
      55908., 56784., 55284., 56184., 57084., 57984., 59796., 60792., 61788.,
      62784., 60924., 61944., 62964., 63984., 62052., 63096., 64140., 65184.};
  const std::array<int, 4> in_shape = {{3, 4, 6, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x4x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      304875., 311400., 366750., 374580., 305955., 312480.,
      414420., 423120., 497640., 508080., 414420., 423120.,
      305955., 312480., 366750., 374580., 304875., 311400.};
  const std::array<int, 4> in_shape = {{3, 4, 6, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x4x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      46392., 48384., 47544., 49584., 48696., 50784., 53304., 55584., 54456.,
      56784., 55608., 57984., 60216., 62784., 61368., 63984., 62520., 65184.};
  const std::array<int, 4> in_shape = {{3, 4, 6, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x4x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      606825., 609750., 619830.,  622800.,  729936., 733500., 745542., 749160.,
      608895., 611910., 621900.,  624960.,  824580., 828840., 841920., 846240.,
      990096., 995280., 1010904., 1016160., 824460., 828840., 841800., 846240.,
      608445., 611910., 621450.,  624960.,  729288., 733500., 744894., 749160.,
      606195., 609750., 619200.,  622800.};
  const std::array<int, 4> in_shape = {{3, 4, 6, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x4x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      91392.,  92784.,  95352.,  96768.,  93648.,  95088.,  97704.,  99168.,
      95904.,  97392.,  100056., 101568., 104928., 106608., 109464., 111168.,
      107184., 108912., 111816., 113568., 109440., 111216., 114168., 115968.,
      118464., 120432., 123576., 125568., 120720., 122736., 125928., 127968.,
      122976., 125040., 128280., 130368.};
  const std::array<int, 4> in_shape = {{3, 4, 6, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x4x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1210725., 1213650., 1216575., 1219500., 1236690., 1239660., 1242630.,
      1245600., 1456308., 1459872., 1463436., 1467000., 1487466., 1491084.,
      1494702., 1498320., 1214775., 1217790., 1220805., 1223820., 1240740.,
      1243800., 1246860., 1249920., 1644900., 1649160., 1653420., 1657680.,
      1679520., 1683840., 1688160., 1692480., 1975008., 1980192., 1985376.,
      1990560., 2016552., 2021808., 2027064., 2032320., 1644540., 1648920.,
      1653300., 1657680., 1679160., 1683600., 1688040., 1692480., 1213425.,
      1216890., 1220355., 1223820., 1239390., 1242900., 1246410., 1249920.,
      1454364., 1458576., 1462788., 1467000., 1485522., 1489788., 1494054.,
      1498320., 1208835., 1212390., 1215945., 1219500., 1234800., 1238400.,
      1242000., 1245600.};
  const std::array<int, 4> in_shape = {{3, 4, 6, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x4x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      181392., 182784., 184176., 185568., 189288., 190704., 192120., 193536.,
      185856., 187296., 188736., 190176., 193944., 195408., 196872., 198336.,
      190320., 191808., 193296., 194784., 198600., 200112., 201624., 203136.,
      208176., 209856., 211536., 213216., 217224., 218928., 220632., 222336.,
      212640., 214368., 216096., 217824., 221880., 223632., 225384., 227136.,
      217104., 218880., 220656., 222432., 226536., 228336., 230136., 231936.,
      234960., 236928., 238896., 240864., 245160., 247152., 249144., 251136.,
      239424., 241440., 243456., 245472., 249816., 251856., 253896., 255936.,
      243888., 245952., 248016., 250080., 254472., 256560., 258648., 260736.};
  const std::array<int, 4> in_shape = {{3, 4, 6, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x4x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1206585., 1219500., 1232505., 1245600., 1451502., 1467000.,
      1482606., 1498320., 1210905., 1223820., 1236825., 1249920.,
      1640460., 1657680., 1675020., 1692480., 1969896., 1990560.,
      2011368., 2032320., 1640460., 1657680., 1675020., 1692480.,
      1210905., 1223820., 1236825., 1249920., 1451502., 1467000.,
      1482606., 1498320., 1206585., 1219500., 1232505., 1245600.};
  const std::array<int, 4> in_shape = {{3, 4, 6, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x4x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      181656., 185568., 189528., 193536., 186168., 190176., 194232., 198336.,
      190680., 194784., 198936., 203136., 208728., 213216., 217752., 222336.,
      213240., 217824., 222456., 227136., 217752., 222432., 227160., 231936.,
      235800., 240864., 245976., 251136., 240312., 245472., 250680., 255936.,
      244824., 250080., 255384., 260736.};
  const std::array<int, 4> in_shape = {{3, 4, 6, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x4x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2407365., 2413170., 2433150., 2439000., 2459115., 2465010., 2485260.,
      2491200., 2895930., 2903004., 2926872., 2934000., 2958030., 2965212.,
      2989404., 2996640., 2415825., 2421810., 2441610., 2447640., 2467575.,
      2473650., 2493720., 2499840., 3272460., 3280920., 3306840., 3315360.,
      3341460., 3350040., 3376320., 3384960., 3929496., 3939792., 3970752.,
      3981120., 4012296., 4022736., 4054128., 4064640., 3272220., 3280920.,
      3306600., 3315360., 3341220., 3350040., 3376080., 3384960., 2414925.,
      2421810., 2440710., 2447640., 2466675., 2473650., 2492820., 2499840.,
      2894634., 2903004., 2925576., 2934000., 2956734., 2965212., 2988108.,
      2996640., 2406105., 2413170., 2431890., 2439000., 2457855., 2465010.,
      2484000., 2491200.};
  const std::array<int, 4> in_shape = {{3, 4, 6, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x4x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      360552., 363312., 368352., 371136., 376248., 379056., 384240., 387072.,
      369480., 372336., 377472., 380352., 385560., 388464., 393744., 396672.,
      378408., 381360., 386592., 389568., 394872., 397872., 403248., 406272.,
      414120., 417456., 423072., 426432., 432120., 435504., 441264., 444672.,
      423048., 426480., 432192., 435648., 441432., 444912., 450768., 454272.,
      431976., 435504., 441312., 444864., 450744., 454320., 460272., 463872.,
      467688., 471600., 477792., 481728., 487992., 491952., 498288., 502272.,
      476616., 480624., 486912., 490944., 497304., 501360., 507792., 511872.,
      485544., 489648., 496032., 500160., 506616., 510768., 517296., 521472.};
  const std::array<int, 4> in_shape = {{3, 4, 6, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x4x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      4808925., 4814730., 4820535., 4826340., 4860450., 4866300., 4872150.,
      4878000., 4912335., 4918230., 4924125., 4930020., 4964580., 4970520.,
      4976460., 4982400., 5784786., 5791860., 5798934., 5806008., 5846616.,
      5853744., 5860872., 5868000., 5908878., 5916060., 5923242., 5930424.,
      5971572., 5978808., 5986044., 5993280., 4825665., 4831650., 4837635.,
      4843620., 4877190., 4883220., 4889250., 4895280., 4929075., 4935150.,
      4941225., 4947300., 4981320., 4987440., 4993560., 4999680., 6536460.,
      6544920., 6553380., 6561840., 6605160., 6613680., 6622200., 6630720.,
      6674340., 6682920., 6691500., 6700080., 6744000., 6752640., 6761280.,
      6769920., 7848696., 7858992., 7869288., 7879584., 7931136., 7941504.,
      7951872., 7962240., 8014152., 8024592., 8035032., 8045472., 8097744.,
      8108256., 8118768., 8129280., 6535740., 6544440., 6553140., 6561840.,
      6604440., 6613200., 6621960., 6630720., 6673620., 6682440., 6691260.,
      6700080., 6743280., 6752160., 6761040., 6769920., 4822965., 4829850.,
      4836735., 4843620., 4874490., 4881420., 4888350., 4895280., 4926375.,
      4933350., 4940325., 4947300., 4978620., 4985640., 4992660., 4999680.,
      5780898., 5789268., 5797638., 5806008., 5842728., 5851152., 5859576.,
      5868000., 5904990., 5913468., 5921946., 5930424., 5967684., 5976216.,
      5984748., 5993280., 4805145., 4812210., 4819275., 4826340., 4856670.,
      4863780., 4870890., 4878000., 4908555., 4915710., 4922865., 4930020.,
      4960800., 4968000., 4975200., 4982400.};
  const std::array<int, 4> in_shape = {{3, 4, 6, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x4x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      718344.,  721104.,  723864.,  726624.,  733920.,  736704.,  739488.,
      742272.,  749688.,  752496.,  755304.,  758112.,  765648.,  768480.,
      771312.,  774144.,  736104.,  738960.,  741816.,  744672.,  752064.,
      754944.,  757824.,  760704.,  768216.,  771120.,  774024.,  776928.,
      784560.,  787488.,  790416.,  793344.,  753864.,  756816.,  759768.,
      762720.,  770208.,  773184.,  776160.,  779136.,  786744.,  789744.,
      792744.,  795744.,  803472.,  806496.,  809520.,  812544.,  824904.,
      828240.,  831576.,  834912.,  842784.,  846144.,  849504.,  852864.,
      860856.,  864240.,  867624.,  871008.,  879120.,  882528.,  885936.,
      889344.,  842664.,  846096.,  849528.,  852960.,  860928.,  864384.,
      867840.,  871296.,  879384.,  882864.,  886344.,  889824.,  898032.,
      901536.,  905040.,  908544.,  860424.,  863952.,  867480.,  871008.,
      879072.,  882624.,  886176.,  889728.,  897912.,  901488.,  905064.,
      908640.,  916944.,  920544.,  924144.,  927744.,  931464.,  935376.,
      939288.,  943200.,  951648.,  955584.,  959520.,  963456.,  972024.,
      975984.,  979944.,  983904.,  992592.,  996576.,  1000560., 1004544.,
      949224.,  953232.,  957240.,  961248.,  969792.,  973824.,  977856.,
      981888.,  990552.,  994608.,  998664.,  1002720., 1011504., 1015584.,
      1019664., 1023744., 966984.,  971088.,  975192.,  979296.,  987936.,
      992064.,  996192.,  1000320., 1009080., 1013232., 1017384., 1021536.,
      1030416., 1034592., 1038768., 1042944.};
  const std::array<int, 4> in_shape = {{3, 4, 6, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x5x4x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {43608., 58280., 43752., 55320., 73810.,
                                         55320., 43752., 58280., 43608.};
  const std::array<int, 4> in_shape = {{3, 5, 4, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x5x4x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {5901., 6072., 6243., 6585., 6756.,
                                         6927., 7269., 7440., 7611.};
  const std::array<int, 4> in_shape = {{3, 5, 4, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x5x4x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      86208.,  87216.,  115192., 116560., 86460.,  87504.,
      109290., 110640., 145790., 147620., 109245., 110640.,
      86352.,  87504.,  115000., 116560., 86028.,  87216.};
  const std::array<int, 4> in_shape = {{3, 5, 4, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x5x4x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      11343., 11802., 11667., 12144., 11991., 12486., 12639., 13170., 12963.,
      13512., 13287., 13854., 13935., 14538., 14259., 14880., 14583., 15222.};
  const std::array<int, 4> in_shape = {{3, 5, 4, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x5x4x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      171408., 172416., 173424., 174432., 229016., 230384., 231752., 233120.,
      171876., 172920., 173964., 175008., 217230., 218580., 219930., 221280.,
      289750., 291580., 293410., 295240., 217095., 218490., 219885., 221280.,
      171552., 172704., 173856., 175008., 228440., 230000., 231560., 233120.,
      170868., 172056., 173244., 174432.};
  const std::array<int, 4> in_shape = {{3, 5, 4, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x5x4x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      22227., 22686., 23145., 23604., 22857., 23334., 23811., 24288., 23487.,
      23982., 24477., 24972., 24747., 25278., 25809., 26340., 25377., 25926.,
      26475., 27024., 26007., 26574., 27141., 27708., 27267., 27870., 28473.,
      29076., 27897., 28518., 29139., 29760., 28527., 29166., 29805., 30444.};
  const std::array<int, 4> in_shape = {{3, 5, 4, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x5x4x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      170076., 174432., 227312., 233120., 170652., 175008.,
      215835., 221280., 287980., 295240., 215835., 221280.,
      170652., 175008., 227312., 233120., 170076., 174432.};
  const std::array<int, 4> in_shape = {{3, 5, 4, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x5x4x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      22362., 23604., 23010., 24288., 23658., 24972., 24954., 26340., 25602.,
      27024., 26250., 27708., 27546., 29076., 28194., 29760., 28842., 30444.};
  const std::array<int, 4> in_shape = {{3, 5, 4, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x5x4x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      338172., 340152., 346848., 348864., 451936., 454624., 463504., 466240.,
      339252., 341304., 347928., 350016., 429015., 431670., 439860., 442560.,
      572360., 575960., 586820., 590480., 428925., 431670., 439770., 442560.,
      339036., 341304., 347712., 350016., 451552., 454624., 463120., 466240.,
      337812., 340152., 346488., 348864.};
  const std::array<int, 4> in_shape = {{3, 5, 4, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x5x4x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      43824., 44724., 46290., 47208., 45084., 46020., 47622., 48576., 46344.,
      47316., 48954., 49944., 48864., 49908., 51618., 52680., 50124., 51204.,
      52950., 54048., 51384., 52500., 54282., 55416., 53904., 55092., 56946.,
      58152., 55164., 56388., 58278., 59520., 56424., 57684., 59610., 60888.};
  const std::array<int, 4> in_shape = {{3, 5, 4, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x5x4x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      674364.,  676344.,  678324.,  680304.,  691680.,  693696.,  695712.,
      697728.,  901184.,  903872.,  906560.,  909248.,  924272.,  927008.,
      929744.,  932480.,  676452.,  678504.,  680556.,  682608.,  693768.,
      695856.,  697944.,  700032.,  855375.,  858030.,  860685.,  863340.,
      877020.,  879720.,  882420.,  885120.,  1141120., 1144720., 1148320.,
      1151920., 1169980., 1173640., 1177300., 1180960., 855105.,  857850.,
      860595.,  863340.,  876750.,  879540.,  882330.,  885120.,  675804.,
      678072.,  680340.,  682608.,  693120.,  695424.,  697728.,  700032.,
      900032.,  903104.,  906176.,  909248.,  923120.,  926240.,  929360.,
      932480.,  673284.,  675624.,  677964.,  680304.,  690600.,  692976.,
      695352.,  697728.};
  const std::array<int, 4> in_shape = {{3, 5, 4, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x5x4x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      86748.,  87648.,  88548.,  89448.,  91662.,  92580.,  93498.,  94416.,
      89232.,  90168.,  91104.,  92040.,  94290.,  95244.,  96198.,  97152.,
      91716.,  92688.,  93660.,  94632.,  96918.,  97908.,  98898.,  99888.,
      96684.,  97728.,  98772.,  99816.,  102174., 103236., 104298., 105360.,
      99168.,  100248., 101328., 102408., 104802., 105900., 106998., 108096.,
      101652., 102768., 103884., 105000., 107430., 108564., 109698., 110832.,
      106620., 107808., 108996., 110184., 112686., 113892., 115098., 116304.,
      109104., 110328., 111552., 112776., 115314., 116556., 117798., 119040.,
      111588., 112848., 114108., 115368., 117942., 119220., 120498., 121776.};
  const std::array<int, 4> in_shape = {{3, 5, 4, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x5x4x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      671700.,  680304.,  688980., 697728., 897776.,  909248.,
      920816.,  932480.,  674004., 682608., 691284.,  700032.,
      852585.,  863340.,  874185., 885120., 1137580., 1151920.,
      1166380., 1180960., 852585., 863340., 874185.,  885120.,
      674004.,  682608.,  691284., 700032., 897776.,  909248.,
      920816.,  932480.,  671700., 680304., 688980.,  697728.};
  const std::array<int, 4> in_shape = {{3, 5, 4, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x5x4x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      87018.,  89448.,  91914.,  94416.,  89538.,  92040.,  94578.,  97152.,
      92058.,  94632.,  97242.,  99888.,  97098.,  99816.,  102570., 105360.,
      99618.,  102408., 105234., 108096., 102138., 105000., 107898., 110832.,
      107178., 110184., 113226., 116304., 109698., 112776., 115890., 119040.,
      112218., 115368., 118554., 121776.};
  const std::array<int, 4> in_shape = {{3, 5, 4, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x5x4x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1339476., 1343400., 1356648., 1360608., 1373964., 1377960., 1391424.,
      1395456., 1790224., 1795552., 1813120., 1818496., 1836208., 1841632.,
      1859488., 1864960., 1343940., 1348008., 1361112., 1365216., 1378428.,
      1382568., 1395888., 1400064., 1699905., 1705170., 1721370., 1726680.,
      1743015., 1748370., 1764840., 1770240., 2268020., 2275160., 2296640.,
      2303840., 2325500., 2332760., 2354600., 2361920., 1699725., 1705170.,
      1721190., 1726680., 1742835., 1748370., 1764660., 1770240., 1343508.,
      1348008., 1360680., 1365216., 1377996., 1382568., 1395456., 1400064.,
      1789456., 1795552., 1812352., 1818496., 1835440., 1841632., 1858720.,
      1864960., 1338756., 1343400., 1355928., 1360608., 1373244., 1377960.,
      1390704., 1395456.};
  const std::array<int, 4> in_shape = {{3, 5, 4, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x5x4x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      172254., 174036., 177096., 178896., 182010., 183828., 186996., 188832.,
      177222., 179076., 182208., 184080., 187266., 189156., 192396., 194304.,
      182190., 184116., 187320., 189264., 192522., 194484., 197796., 199776.,
      192126., 194196., 197544., 199632., 203034., 205140., 208596., 210720.,
      197094., 199236., 202656., 204816., 208290., 210468., 213996., 216192.,
      202062., 204276., 207768., 210000., 213546., 215796., 219396., 221664.,
      211998., 214356., 217992., 220368., 224058., 226452., 230196., 232608.,
      216966., 219396., 223104., 225552., 229314., 231780., 235596., 238080.,
      221934., 224436., 228216., 230736., 234570., 237108., 240996., 243552.};
  const std::array<int, 4> in_shape = {{3, 5, 4, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x5x4x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2675028., 2678952., 2682876., 2686800., 2709336., 2713296., 2717256.,
      2721216., 2743932., 2747928., 2751924., 2755920., 2778816., 2782848.,
      2786880., 2790912., 3575120., 3580448., 3585776., 3591104., 3620864.,
      3626240., 3631616., 3636992., 3666992., 3672416., 3677840., 3683264.,
      3713504., 3718976., 3724448., 3729920., 2683812., 2687880., 2691948.,
      2696016., 2718120., 2722224., 2726328., 2730432., 2752716., 2756856.,
      2760996., 2765136., 2787600., 2791776., 2795952., 2800128., 3394545.,
      3399810., 3405075., 3410340., 3437430., 3442740., 3448050., 3453360.,
      3480675., 3486030., 3491385., 3496740., 3524280., 3529680., 3535080.,
      3540480., 4528900., 4536040., 4543180., 4550320., 4586080., 4593280.,
      4600480., 4607680., 4643740., 4651000., 4658260., 4665520., 4701880.,
      4709200., 4716520., 4723840., 3394005., 3399450., 3404895., 3410340.,
      3436890., 3442380., 3447870., 3453360., 3480135., 3485670., 3491205.,
      3496740., 3523740., 3529320., 3534900., 3540480., 2682516., 2687016.,
      2691516., 2696016., 2716824., 2721360., 2725896., 2730432., 2751420.,
      2755992., 2760564., 2765136., 2786304., 2790912., 2795520., 2800128.,
      3572816., 3578912., 3585008., 3591104., 3618560., 3624704., 3630848.,
      3636992., 3664688., 3670880., 3677072., 3683264., 3711200., 3717440.,
      3723680., 3729920., 2672868., 2677512., 2682156., 2686800., 2707176.,
      2711856., 2716536., 2721216., 2741772., 2746488., 2751204., 2755920.,
      2776656., 2781408., 2786160., 2790912.};
  const std::array<int, 4> in_shape = {{3, 5, 4, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x5x4x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      342726., 344508., 346290., 348072., 352392., 354192., 355992., 357792.,
      362202., 364020., 365838., 367656., 372156., 373992., 375828., 377664.,
      352590., 354444., 356298., 358152., 362544., 364416., 366288., 368160.,
      372642., 374532., 376422., 378312., 382884., 384792., 386700., 388608.,
      362454., 364380., 366306., 368232., 372696., 374640., 376584., 378528.,
      383082., 385044., 387006., 388968., 393612., 395592., 397572., 399552.,
      382182., 384252., 386322., 388392., 393000., 395088., 397176., 399264.,
      403962., 406068., 408174., 410280., 415068., 417192., 419316., 421440.,
      392046., 394188., 396330., 398472., 403152., 405312., 407472., 409632.,
      414402., 416580., 418758., 420936., 425796., 427992., 430188., 432384.,
      401910., 404124., 406338., 408552., 413304., 415536., 417768., 420000.,
      424842., 427092., 429342., 431592., 436524., 438792., 441060., 443328.,
      421638., 423996., 426354., 428712., 433608., 435984., 438360., 440736.,
      445722., 448116., 450510., 452904., 457980., 460392., 462804., 465216.,
      431502., 433932., 436362., 438792., 443760., 446208., 448656., 451104.,
      456162., 458628., 461094., 463560., 468708., 471192., 473676., 476160.,
      441366., 443868., 446370., 448872., 453912., 456432., 458952., 461472.,
      466602., 469140., 471678., 474216., 479436., 481992., 484548., 487104.};
  const std::array<int, 4> in_shape = {{3, 5, 4, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x5x5x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {90440.,  113260., 90680.,
                                         114700., 143450., 114700.,
                                         90680.,  113260., 90440.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x5x5x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {16434., 16812., 17190., 18324., 18702.,
                                         19080., 20214., 20592., 20970.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x5x5x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      179200., 180880., 224390., 226520., 179632., 181360.,
      227150., 229400., 284050., 286900., 227090., 229400.,
      179440., 181360., 224090., 226520., 178912., 180880.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x5x5x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      32004., 32868., 32733., 33624., 33462., 34380., 35649., 36648., 36378.,
      37404., 37107., 38160., 39294., 40428., 40023., 41184., 40752., 41940.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x5x5x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      356720., 358400., 360080., 361760., 446650., 448780., 450910., 453040.,
      357536., 359264., 360992., 362720., 452050., 454300., 456550., 458800.,
      565250., 568100., 570950., 573800., 451870., 454180., 456490., 458800.,
      356960., 358880., 360800., 362720., 445750., 448180., 450610., 453040.,
      355856., 357824., 359792., 361760.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x5x5x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      63144., 64008., 64872., 65736., 64575., 65466., 66357., 67248., 66006.,
      66924., 67842., 68760., 70299., 71298., 72297., 73296., 71730., 72756.,
      73782., 74808., 73161., 74214., 75267., 76320., 77454., 78588., 79722.,
      80856., 78885., 80046., 81207., 82368., 80316., 81504., 82692., 83880.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x5x5x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      354512., 361760., 443980., 453040., 355472., 362720.,
      449740., 458800., 562475., 573800., 449740., 458800.,
      355472., 362720., 443980., 453040., 354512., 361760.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x5x5x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      63279., 65736., 64737., 67248., 66195., 68760., 70569., 73296., 72027.,
      74808., 73485., 76320., 77859., 80856., 79317., 82368., 80775., 83880.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x5x5x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      705712.,  709024.,  720160., 723520., 883760.,  887960.,
      901820.,  906080.,  707536., 710944., 721984.,  725440.,
      895040.,  899480.,  913100., 917600., 1119325., 1124950.,
      1141900., 1147600., 894920., 899480., 912980.,  917600.,
      707152.,  710944.,  721600., 725440., 883160.,  887960.,
      901220.,  906080.,  705136., 709024., 719584.,  723520.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x5x5x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      124857., 126558., 129744., 131472., 127719., 129474., 132714., 134496.,
      130581., 132390., 135684., 137520., 139167., 141138., 144594., 146592.,
      142029., 144054., 147564., 149616., 144891., 146970., 150534., 152640.,
      153477., 155718., 159444., 161712., 156339., 158634., 162414., 164736.,
      159201., 161550., 165384., 167760.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x5x5x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1408112., 1411424., 1414736., 1418048., 1436960., 1440320., 1443680.,
      1447040., 1763320., 1767520., 1771720., 1775920., 1799380., 1803640.,
      1807900., 1812160., 1411664., 1415072., 1418480., 1421888., 1440512.,
      1443968., 1447424., 1450880., 1785640., 1790080., 1794520., 1798960.,
      1821700., 1826200., 1830700., 1835200., 2233025., 2238650., 2244275.,
      2249900., 2278100., 2283800., 2289500., 2295200., 1785280., 1789840.,
      1794400., 1798960., 1821340., 1825960., 1830580., 1835200., 1410512.,
      1414304., 1418096., 1421888., 1439360., 1443200., 1447040., 1450880.,
      1761520., 1766320., 1771120., 1775920., 1797580., 1802440., 1807300.,
      1812160., 1406384., 1410272., 1414160., 1418048., 1435232., 1439168.,
      1443104., 1447040.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x5x5x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      248013., 249714., 251415., 253116., 257760., 259488., 261216., 262944.,
      253683., 255438., 257193., 258948., 263646., 265428., 267210., 268992.,
      259353., 261162., 262971., 264780., 269532., 271368., 273204., 275040.,
      276363., 278334., 280305., 282276., 287190., 289188., 291186., 293184.,
      282033., 284058., 286083., 288108., 293076., 295128., 297180., 299232.,
      287703., 289782., 291861., 293940., 298962., 301068., 303174., 305280.,
      304713., 306954., 309195., 311436., 316620., 318888., 321156., 323424.,
      310383., 312678., 314973., 317268., 322506., 324828., 327150., 329472.,
      316053., 318402., 320751., 323100., 328392., 330768., 333144., 335520.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x5x5x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1403696., 1418048., 1432496., 1447040., 1757980., 1775920.,
      1793980., 1812160., 1407536., 1421888., 1436336., 1450880.,
      1781020., 1798960., 1817020., 1835200., 2227475., 2249900.,
      2272475., 2295200., 1781020., 1798960., 1817020., 1835200.,
      1407536., 1421888., 1436336., 1450880., 1757980., 1775920.,
      1793980., 1812160., 1403696., 1418048., 1432496., 1447040.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x5x5x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      248283., 253116., 258003., 262944., 254007., 258948., 263943., 268992.,
      259731., 264780., 269883., 275040., 276903., 282276., 287703., 293184.,
      282627., 288108., 293643., 299232., 288351., 293940., 299583., 305280.,
      305523., 311436., 317403., 323424., 311247., 317268., 323343., 329472.,
      316971., 323100., 329283., 335520.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x5x5x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2800816., 2807392., 2829472., 2836096., 2858320., 2864992., 2887360.,
      2894080., 3507620., 3515960., 3543440., 3551840., 3579500., 3587960.,
      3615800., 3624320., 2808304., 2815072., 2836960., 2843776., 2865808.,
      2872672., 2894848., 2901760., 3553220., 3562040., 3589040., 3597920.,
      3625100., 3634040., 3661400., 3670400., 4443775., 4454950., 4488550.,
      4499800., 4533625., 4544950., 4579000., 4590400., 3552980., 3562040.,
      3588800., 3597920., 3624860., 3634040., 3661160., 3670400., 2807536.,
      2815072., 2836192., 2843776., 2865040., 2872672., 2894080., 2901760.,
      3506420., 3515960., 3542240., 3551840., 3578300., 3587960., 3614600.,
      3624320., 2799664., 2807392., 2828320., 2836096., 2857168., 2864992.,
      2886208., 2894080.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x5x5x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      493191., 496566., 502830., 506232., 512577., 516006., 522432., 525888.,
      504531., 508014., 514386., 517896., 524349., 527886., 534420., 537984.,
      515871., 519462., 525942., 529560., 536121., 539766., 546408., 550080.,
      549891., 553806., 560610., 564552., 571437., 575406., 582372., 586368.,
      561231., 565254., 572166., 576216., 583209., 587286., 594360., 598464.,
      572571., 576702., 583722., 587880., 594981., 599166., 606348., 610560.,
      606591., 611046., 618390., 622872., 630297., 634806., 642312., 646848.,
      617931., 622494., 629946., 634536., 642069., 646686., 654300., 658944.,
      629271., 633942., 641502., 646200., 653841., 658566., 666288., 671040.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x5x5x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5595056., 5601632., 5608208., 5614784., 5652320., 5658944., 5665568.,
      5672192., 5709968., 5716640., 5723312., 5729984., 5768000., 5774720.,
      5781440., 5788160., 7006900., 7015240., 7023580., 7031920., 7078480.,
      7086880., 7095280., 7103680., 7150540., 7159000., 7167460., 7175920.,
      7223080., 7231600., 7240120., 7248640., 5609840., 5616608., 5623376.,
      5630144., 5667104., 5673920., 5680736., 5687552., 5724752., 5731616.,
      5738480., 5745344., 5782784., 5789696., 5796608., 5803520., 7097620.,
      7106440., 7115260., 7124080., 7169200., 7178080., 7186960., 7195840.,
      7241260., 7250200., 7259140., 7268080., 7313800., 7322800., 7331800.,
      7340800., 8876375., 8887550., 8898725., 8909900., 8965850., 8977100.,
      8988350., 8999600., 9055925., 9067250., 9078575., 9089900., 9146600.,
      9158000., 9169400., 9180800., 7096900., 7105960., 7115020., 7124080.,
      7168480., 7177600., 7186720., 7195840., 7240540., 7249720., 7258900.,
      7268080., 7313080., 7322320., 7331560., 7340800., 5607536., 5615072.,
      5622608., 5630144., 5664800., 5672384., 5679968., 5687552., 5722448.,
      5730080., 5737712., 5745344., 5780480., 5788160., 5795840., 5803520.,
      7003300., 7012840., 7022380., 7031920., 7074880., 7084480., 7094080.,
      7103680., 7146940., 7156600., 7166260., 7175920., 7219480., 7229200.,
      7238920., 7248640., 5591600., 5599328., 5607056., 5614784., 5648864.,
      5656640., 5664416., 5672192., 5706512., 5714336., 5722160., 5729984.,
      5764544., 5772416., 5780288., 5788160.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x5x5x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      983007.,  986382.,  989757.,  993132.,  1002258., 1005660., 1009062.,
      1012464., 1021725., 1025154., 1028583., 1032012., 1041408., 1044864.,
      1048320., 1051776., 1005579., 1009062., 1012545., 1016028., 1025262.,
      1028772., 1032282., 1035792., 1045161., 1048698., 1052235., 1055772.,
      1065276., 1068840., 1072404., 1075968., 1028151., 1031742., 1035333.,
      1038924., 1048266., 1051884., 1055502., 1059120., 1068597., 1072242.,
      1075887., 1079532., 1089144., 1092816., 1096488., 1100160., 1095867.,
      1099782., 1103697., 1107612., 1117278., 1121220., 1125162., 1129104.,
      1138905., 1142874., 1146843., 1150812., 1160748., 1164744., 1168740.,
      1172736., 1118439., 1122462., 1126485., 1130508., 1140282., 1144332.,
      1148382., 1152432., 1162341., 1166418., 1170495., 1174572., 1184616.,
      1188720., 1192824., 1196928., 1141011., 1145142., 1149273., 1153404.,
      1163286., 1167444., 1171602., 1175760., 1185777., 1189962., 1194147.,
      1198332., 1208484., 1212696., 1216908., 1221120., 1208727., 1213182.,
      1217637., 1222092., 1232298., 1236780., 1241262., 1245744., 1256085.,
      1260594., 1265103., 1269612., 1280088., 1284624., 1289160., 1293696.,
      1231299., 1235862., 1240425., 1244988., 1255302., 1259892., 1264482.,
      1269072., 1279521., 1284138., 1288755., 1293372., 1303956., 1308600.,
      1313244., 1317888., 1253871., 1258542., 1263213., 1267884., 1278306.,
      1283004., 1287702., 1292400., 1302957., 1307682., 1312407., 1317132.,
      1327824., 1332576., 1337328., 1342080.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x5x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {162300., 195060., 162660.,
                                         205800., 247065., 205800.,
                                         162660., 195060., 162300.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x5x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {34902., 35568., 36234., 38898., 39564.,
                                         40230., 42894., 43560., 44226.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x5x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      322080., 324600., 387060., 390120., 322740., 325320.,
      408225., 411600., 490035., 494130., 408150., 411600.,
      322440., 325320., 386628., 390120., 321660., 324600.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x5x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      68418., 69804., 69714., 71136., 71010., 72468., 76194., 77796., 77490.,
      79128., 78786., 80460., 83970., 85788., 85266., 87120., 86562., 88452.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x5x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      641640., 644160., 646680., 649200., 771060., 774120., 777180., 780240.,
      642900., 645480., 648060., 650640., 813075., 816450., 819825., 823200.,
      975975., 980070., 984165., 988260., 812850., 816300., 819750., 823200.,
      642000., 644880., 647760., 650640., 769764., 773256., 776748., 780240.,
      640380., 643320., 646260., 649200.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x5x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      135450., 136836., 138222., 139608., 138006., 139428., 140850., 142272.,
      140562., 142020., 143478., 144936., 150786., 152388., 153990., 155592.,
      153342., 154980., 156618., 158256., 155898., 157572., 159246., 160920.,
      166122., 167940., 169758., 171576., 168678., 170532., 172386., 174240.,
      171234., 173124., 175014., 176904.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x5x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      638340., 649200., 767208., 780240., 639780., 650640.,
      809625., 823200., 971970., 988260., 809625., 823200.,
      639780., 650640., 767208., 780240., 638340., 649200.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x5x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      135540., 139608., 138132., 142272., 140724., 144936.,
      151092., 155592., 153684., 158256., 156276., 160920.,
      166644., 171576., 169236., 174240., 171828., 176904.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x5x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1271700., 1276680., 1293360., 1298400., 1528368., 1534416.,
      1554360., 1560480., 1274460., 1279560., 1296120., 1301280.,
      1612575., 1619250., 1639650., 1646400., 1935840., 1943940.,
      1968330., 1976520., 1612425., 1619250., 1639500., 1646400.,
      1273860., 1279560., 1295520., 1301280., 1527504., 1534416.,
      1553496., 1560480., 1270860., 1276680., 1292520., 1298400.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x5x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      268344., 271080., 276444., 279216., 273456., 276264., 281700., 284544.,
      278568., 281448., 286956., 289872., 299016., 302184., 307980., 311184.,
      304128., 307368., 313236., 316512., 309240., 312552., 318492., 321840.,
      329688., 333288., 339516., 343152., 334800., 338472., 344772., 348480.,
      339912., 343656., 350028., 353808.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x5x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2538420., 2543400., 2548380., 2553360., 2581680., 2586720., 2591760.,
      2596800., 3050688., 3056736., 3062784., 3068832., 3102600., 3108720.,
      3114840., 3120960., 2543820., 2548920., 2554020., 2559120., 2587080.,
      2592240., 2597400., 2602560., 3218475., 3225150., 3231825., 3238500.,
      3272550., 3279300., 3286050., 3292800., 3863580., 3871680., 3879780.,
      3887880., 3928470., 3936660., 3944850., 3953040., 3218025., 3224850.,
      3231675., 3238500., 3272100., 3279000., 3285900., 3292800., 2542020.,
      2547720., 2553420., 2559120., 2585280., 2591040., 2596800., 2602560.,
      3048096., 3055008., 3061920., 3068832., 3100008., 3106992., 3113976.,
      3120960., 2535900., 2541720., 2547540., 2553360., 2579160., 2585040.,
      2590920., 2596800.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x5x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      533952., 536688., 539424., 542160., 550116., 552888., 555660., 558432.,
      544104., 546912., 549720., 552528., 560556., 563400., 566244., 569088.,
      554256., 557136., 560016., 562896., 570996., 573912., 576828., 579744.,
      594864., 598032., 601200., 604368., 612756., 615960., 619164., 622368.,
      605016., 608256., 611496., 614736., 623196., 626472., 629748., 633024.,
      615168., 618480., 621792., 625104., 633636., 636984., 640332., 643680.,
      655776., 659376., 662976., 666576., 675396., 679032., 682668., 686304.,
      665928., 669600., 673272., 676944., 685836., 689544., 693252., 696960.,
      676080., 679824., 683568., 687312., 696276., 700056., 703836., 707616.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x5x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2531820., 2553360., 2575020., 2596800., 3042984., 3068832.,
      3094824., 3120960., 2537580., 2559120., 2580780., 2602560.,
      3211575., 3238500., 3265575., 3292800., 3855570., 3887880.,
      3920370., 3953040., 3211575., 3238500., 3265575., 3292800.,
      2537580., 2559120., 2580780., 2602560., 3042984., 3068832.,
      3094824., 3120960., 2531820., 2553360., 2575020., 2596800.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x5x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      534132., 542160., 550260., 558432., 544356., 552528., 560772., 569088.,
      554580., 562896., 571284., 579744., 595476., 604368., 613332., 622368.,
      605700., 614736., 623844., 633024., 615924., 625104., 634356., 643680.,
      656820., 666576., 676404., 686304., 667044., 676944., 686916., 696960.,
      677268., 687312., 697428., 707616.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x5x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5053740., 5063640., 5096760., 5106720., 5140020., 5150040., 5183520.,
      5193600., 6073944., 6085968., 6125568., 6137664., 6177480., 6189648.,
      6229680., 6241920., 5065020., 5075160., 5108040., 5118240., 5151300.,
      5161560., 5194800., 5205120., 6409875., 6423150., 6463650., 6477000.,
      6517725., 6531150., 6572100., 6585600., 7695030., 7711140., 7759560.,
      7775760., 7824450., 7840740., 7889700., 7906080., 6409575., 6423150.,
      6463350., 6477000., 6517425., 6531150., 6571800., 6585600., 5063820.,
      5075160., 5106840., 5118240., 5150100., 5161560., 5193600., 5205120.,
      6072216., 6085968., 6123840., 6137664., 6175752., 6189648., 6227952.,
      6241920., 5052060., 5063640., 5095080., 5106720., 5138340., 5150040.,
      5181840., 5193600.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x5x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1062828., 1068264., 1078848., 1084320., 1095012., 1100520., 1111320.,
      1116864., 1083132., 1088712., 1099440., 1105056., 1115892., 1121544.,
      1132488., 1138176., 1103436., 1109160., 1120032., 1125792., 1136772.,
      1142568., 1153656., 1159488., 1184652., 1190952., 1202400., 1208736.,
      1220292., 1226664., 1238328., 1244736., 1204956., 1211400., 1222992.,
      1229472., 1241172., 1247688., 1259496., 1266048., 1225260., 1231848.,
      1243584., 1250208., 1262052., 1268712., 1280664., 1287360., 1306476.,
      1313640., 1325952., 1333152., 1345572., 1352808., 1365336., 1372608.,
      1326780., 1334088., 1346544., 1353888., 1366452., 1373832., 1386504.,
      1393920., 1347084., 1354536., 1367136., 1374624., 1387332., 1394856.,
      1407672., 1415232.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x5x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      10097580., 10107480., 10117380., 10127280., 10183560., 10193520.,
      10203480., 10213440., 10270020., 10280040., 10290060., 10300080.,
      10356960., 10367040., 10377120., 10387200., 12135864., 12147888.,
      12159912., 12171936., 12239040., 12251136., 12263232., 12275328.,
      12342792., 12354960., 12367128., 12379296., 12447120., 12459360.,
      12471600., 12483840., 10119900., 10130040., 10140180., 10150320.,
      10205880., 10216080., 10226280., 10236480., 10292340., 10302600.,
      10312860., 10323120., 10379280., 10389600., 10399920., 10410240.,
      12806475., 12819750., 12833025., 12846300., 12913950., 12927300.,
      12940650., 12954000., 13022025., 13035450., 13048875., 13062300.,
      13130700., 13144200., 13157700., 13171200., 15373950., 15390060.,
      15406170., 15422280., 15502920., 15519120., 15535320., 15551520.,
      15632610., 15648900., 15665190., 15681480., 15763020., 15779400.,
      15795780., 15812160., 12805575., 12819150., 12832725., 12846300.,
      12913050., 12926700., 12940350., 12954000., 13021125., 13034850.,
      13048575., 13062300., 13129800., 13143600., 13157400., 13171200.,
      10116300., 10127640., 10138980., 10150320., 10202280., 10213680.,
      10225080., 10236480., 10288740., 10300200., 10311660., 10323120.,
      10375680., 10387200., 10398720., 10410240., 12130680., 12144432.,
      12158184., 12171936., 12233856., 12247680., 12261504., 12275328.,
      12337608., 12351504., 12365400., 12379296., 12441936., 12455904.,
      12469872., 12483840., 10092540., 10104120., 10115700., 10127280.,
      10178520., 10190160., 10201800., 10213440., 10264980., 10276680.,
      10288380., 10300080., 10351920., 10363680., 10375440., 10387200.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x5x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2120220., 2125656., 2131092., 2136528., 2152224., 2157696., 2163168.,
      2168640., 2184516., 2190024., 2195532., 2201040., 2217096., 2222640.,
      2228184., 2233728., 2160684., 2166264., 2171844., 2177424., 2193264.,
      2198880., 2204496., 2210112., 2226132., 2231784., 2237436., 2243088.,
      2259288., 2264976., 2270664., 2276352., 2201148., 2206872., 2212596.,
      2218320., 2234304., 2240064., 2245824., 2251584., 2267748., 2273544.,
      2279340., 2285136., 2301480., 2307312., 2313144., 2318976., 2363004.,
      2369304., 2375604., 2381904., 2398464., 2404800., 2411136., 2417472.,
      2434212., 2440584., 2446956., 2453328., 2470248., 2476656., 2483064.,
      2489472., 2403468., 2409912., 2416356., 2422800., 2439504., 2445984.,
      2452464., 2458944., 2475828., 2482344., 2488860., 2495376., 2512440.,
      2518992., 2525544., 2532096., 2443932., 2450520., 2457108., 2463696.,
      2480544., 2487168., 2493792., 2500416., 2517444., 2524104., 2530764.,
      2537424., 2554632., 2561328., 2568024., 2574720., 2605788., 2612952.,
      2620116., 2627280., 2644704., 2651904., 2659104., 2666304., 2683908.,
      2691144., 2698380., 2705616., 2723400., 2730672., 2737944., 2745216.,
      2646252., 2653560., 2660868., 2668176., 2685744., 2693088., 2700432.,
      2707776., 2725524., 2732904., 2740284., 2747664., 2765592., 2773008.,
      2780424., 2787840., 2686716., 2694168., 2701620., 2709072., 2726784.,
      2734272., 2741760., 2749248., 2767140., 2774664., 2782188., 2789712.,
      2807784., 2815344., 2822904., 2830464.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x6x4x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {78420., 104730., 78600.,
                                         95220., 127020., 95220.,
                                         78600., 104730., 78420.};
  const std::array<int, 4> in_shape = {{3, 6, 4, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x6x4x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {12768., 13068., 13368., 13968., 14268.,
                                         14568., 15168., 15468., 15768.};
  const std::array<int, 4> in_shape = {{3, 6, 4, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x6x4x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      155310., 156840., 207390., 209460., 155625., 157200.,
      188496., 190440., 251412., 254040., 188442., 190440.,
      155490., 157200., 207150., 209460., 155085., 156840.};
  const std::array<int, 4> in_shape = {{3, 6, 4, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x6x4x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      24780., 25536., 25356., 26136., 25932., 26736., 27084., 27936., 27660.,
      28536., 28236., 29136., 29388., 30336., 29964., 30936., 30540., 31536.};
  const std::array<int, 4> in_shape = {{3, 6, 4, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x6x4x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      309090., 310620., 312150., 313680., 412710., 414780., 416850., 418920.,
      309675., 311250., 312825., 314400., 375048., 376992., 378936., 380880.,
      500196., 502824., 505452., 508080., 374886., 376884., 378882., 380880.,
      309270., 310980., 312690., 314400., 411990., 414300., 416610., 418920.,
      308415., 310170., 311925., 313680.};
  const std::array<int, 4> in_shape = {{3, 6, 4, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x6x4x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      48804., 49560., 50316., 51072., 49932., 50712., 51492., 52272., 51060.,
      51864., 52668., 53472., 53316., 54168., 55020., 55872., 54444., 55320.,
      56196., 57072., 55572., 56472., 57372., 58272., 57828., 58776., 59724.,
      60672., 58956., 59928., 60900., 61872., 60084., 61080., 62076., 63072.};
  const std::array<int, 4> in_shape = {{3, 6, 4, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x6x4x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      307155., 313680., 410220., 418920., 307875., 314400.,
      373050., 380880., 497640., 508080., 373050., 380880.,
      307875., 314400., 410220., 418920., 307155., 313680.};
  const std::array<int, 4> in_shape = {{3, 6, 4, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x6x4x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      48984., 51072., 50136., 52272., 51288., 53472., 53592., 55872., 54744.,
      57072., 55896., 58272., 58200., 60672., 59352., 61872., 60504., 63072.};
  const std::array<int, 4> in_shape = {{3, 6, 4, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x6x4x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      611295., 614310., 624300.,  627360.,  816360., 820440., 833700., 837840.,
      612645., 615750., 625650.,  628800.,  742266., 746100., 757872., 761760.,
      990096., 995280., 1010904., 1016160., 742158., 746100., 757764., 761760.,
      612375., 615750., 625380.,  628800.,  815880., 820440., 833220., 837840.,
      610845., 614310., 623850.,  627360.};
  const std::array<int, 4> in_shape = {{3, 6, 4, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x6x4x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      96480.,  97968.,  100632., 102144., 98736.,  100272., 102984., 104544.,
      100992., 102576., 105336., 106944., 105504., 107184., 110040., 111744.,
      107760., 109488., 112392., 114144., 110016., 111792., 114744., 116544.,
      114528., 116400., 119448., 121344., 116784., 118704., 121800., 123744.,
      119040., 121008., 124152., 126144.};
  const std::array<int, 4> in_shape = {{3, 6, 4, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x6x4x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1219575., 1222590., 1225605., 1228620., 1245540., 1248600., 1251660.,
      1254720., 1628640., 1632720., 1636800., 1640880., 1663260., 1667400.,
      1671540., 1675680., 1222185., 1225290., 1228395., 1231500., 1248150.,
      1251300., 1254450., 1257600., 1480698., 1484532., 1488366., 1492200.,
      1511856., 1515744., 1519632., 1523520., 1975008., 1980192., 1985376.,
      1990560., 2016552., 2021808., 2027064., 2032320., 1480374., 1484316.,
      1488258., 1492200., 1511532., 1515528., 1519524., 1523520., 1221375.,
      1224750., 1228125., 1231500., 1247340., 1250760., 1254180., 1257600.,
      1627200., 1631760., 1636320., 1640880., 1661820., 1666440., 1671060.,
      1675680., 1218225., 1221690., 1225155., 1228620., 1244190., 1247700.,
      1251210., 1254720.};
  const std::array<int, 4> in_shape = {{3, 6, 4, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x6x4x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      191472., 192960., 194448., 195936., 199752., 201264., 202776., 204288.,
      195936., 197472., 199008., 200544., 204408., 205968., 207528., 209088.,
      200400., 201984., 203568., 205152., 209064., 210672., 212280., 213888.,
      209328., 211008., 212688., 214368., 218376., 220080., 221784., 223488.,
      213792., 215520., 217248., 218976., 223032., 224784., 226536., 228288.,
      218256., 220032., 221808., 223584., 227688., 229488., 231288., 233088.,
      227184., 229056., 230928., 232800., 237000., 238896., 240792., 242688.,
      231648., 233568., 235488., 237408., 241656., 243600., 245544., 247488.,
      236112., 238080., 240048., 242016., 246312., 248304., 250296., 252288.};
  const std::array<int, 4> in_shape = {{3, 6, 4, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x6x4x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1215705., 1228620., 1241625., 1254720., 1623660., 1640880.,
      1658220., 1675680., 1218585., 1231500., 1244505., 1257600.,
      1476702., 1492200., 1507806., 1523520., 1969896., 1990560.,
      2011368., 2032320., 1476702., 1492200., 1507806., 1523520.,
      1218585., 1231500., 1244505., 1257600., 1623660., 1640880.,
      1658220., 1675680., 1215705., 1228620., 1241625., 1254720.};
  const std::array<int, 4> in_shape = {{3, 6, 4, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x6x4x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      191832., 195936., 200088., 204288., 196344., 200544., 204792., 209088.,
      200856., 205152., 209496., 213888., 209880., 214368., 218904., 223488.,
      214392., 218976., 223608., 228288., 218904., 223584., 228312., 233088.,
      227928., 232800., 237720., 242688., 232440., 237408., 242424., 247488.,
      236952., 242016., 247128., 252288.};
  const std::array<int, 4> in_shape = {{3, 6, 4, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x6x4x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2425425., 2431410., 2451210., 2457240., 2477175., 2483250., 2503320.,
      2509440., 3239220., 3247320., 3273600., 3281760., 3308220., 3316440.,
      3343080., 3351360., 2431005., 2437170., 2456790., 2463000., 2482755.,
      2489010., 2508900., 2515200., 2945790., 2953404., 2976732., 2984400.,
      3007890., 3015612., 3039264., 3047040., 3929496., 3939792., 3970752.,
      3981120., 4012296., 4022736., 4054128., 4064640., 2945574., 2953404.,
      2976516., 2984400., 3007674., 3015612., 3039048., 3047040., 2430465.,
      2437170., 2456250., 2463000., 2482215., 2489010., 2508360., 2515200.,
      3238260., 3247320., 3272640., 3281760., 3307260., 3316440., 3342120.,
      3351360., 2424525., 2431410., 2450310., 2457240., 2476275., 2483250.,
      2502420., 2509440.};
  const std::array<int, 4> in_shape = {{3, 6, 4, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x6x4x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      380712., 383664., 388896., 391872., 397176., 400176., 405552., 408576.,
      389640., 392688., 398016., 401088., 406488., 409584., 415056., 418176.,
      398568., 401712., 407136., 410304., 415800., 418992., 424560., 427776.,
      416424., 419760., 425376., 428736., 434424., 437808., 443568., 446976.,
      425352., 428784., 434496., 437952., 443736., 447216., 453072., 456576.,
      434280., 437808., 443616., 447168., 453048., 456624., 462576., 466176.,
      452136., 455856., 461856., 465600., 471672., 475440., 481584., 485376.,
      461064., 464880., 470976., 474816., 480984., 484848., 491088., 494976.,
      469992., 473904., 480096., 484032., 490296., 494256., 500592., 504576.};
  const std::array<int, 4> in_shape = {{3, 6, 4, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x6x4x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      4844865., 4850850., 4856835., 4862820., 4896390., 4902420., 4908450.,
      4914480., 4948275., 4954350., 4960425., 4966500., 5000520., 5006640.,
      5012760., 5018880., 6470340., 6478440., 6486540., 6494640., 6539040.,
      6547200., 6555360., 6563520., 6608220., 6616440., 6624660., 6632880.,
      6677880., 6686160., 6694440., 6702720., 4855845., 4862010., 4868175.,
      4874340., 4907370., 4913580., 4919790., 4926000., 4959255., 4965510.,
      4971765., 4978020., 5011500., 5017800., 5024100., 5030400., 5883966.,
      5891580., 5899194., 5906808., 5945796., 5953464., 5961132., 5968800.,
      6008058., 6015780., 6023502., 6031224., 6070752., 6078528., 6086304.,
      6094080., 7848696., 7858992., 7869288., 7879584., 7931136., 7941504.,
      7951872., 7962240., 8014152., 8024592., 8035032., 8045472., 8097744.,
      8108256., 8118768., 8129280., 5883318., 5891148., 5898978., 5906808.,
      5945148., 5953032., 5960916., 5968800., 6007410., 6015348., 6023286.,
      6031224., 6070104., 6078096., 6086088., 6094080., 4854225., 4860930.,
      4867635., 4874340., 4905750., 4912500., 4919250., 4926000., 4957635.,
      4964430., 4971225., 4978020., 5009880., 5016720., 5023560., 5030400.,
      6467460., 6476520., 6485580., 6494640., 6536160., 6545280., 6554400.,
      6563520., 6605340., 6614520., 6623700., 6632880., 6675000., 6684240.,
      6693480., 6702720., 4842165., 4849050., 4855935., 4862820., 4893690.,
      4900620., 4907550., 4914480., 4945575., 4952550., 4959525., 4966500.,
      4997820., 5004840., 5011860., 5018880.};
  const std::array<int, 4> in_shape = {{3, 6, 4, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x6x4x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      758472., 761424.,  764376.,  767328., 774816., 777792., 780768.,
      783744., 791352.,  794352.,  797352., 800352., 808080., 811104.,
      814128., 817152.,  776232.,  779280., 782328., 785376., 792960.,
      796032., 799104.,  802176.,  809880., 812976., 816072., 819168.,
      826992., 830112.,  833232.,  836352., 793992., 797136., 800280.,
      803424., 811104.,  814272.,  817440., 820608., 828408., 831600.,
      834792., 837984.,  845904.,  849120., 852336., 855552., 829512.,
      832848., 836184.,  839520.,  847392., 850752., 854112., 857472.,
      865464., 868848.,  872232.,  875616., 883728., 887136., 890544.,
      893952., 847272.,  850704.,  854136., 857568., 865536., 868992.,
      872448., 875904.,  883992.,  887472., 890952., 894432., 902640.,
      906144., 909648.,  913152.,  865032., 868560., 872088., 875616.,
      883680., 887232.,  890784.,  894336., 902520., 906096., 909672.,
      913248., 921552.,  925152.,  928752., 932352., 900552., 904272.,
      907992., 911712.,  919968.,  923712., 927456., 931200., 939576.,
      943344., 947112.,  950880.,  959376., 963168., 966960., 970752.,
      918312., 922128.,  925944.,  929760., 938112., 941952., 945792.,
      949632., 958104.,  961968.,  965832., 969696., 978288., 982176.,
      986064., 989952.,  936072.,  939984., 943896., 947808., 956256.,
      960192., 964128.,  968064.,  976632., 980592., 984552., 988512.,
      997200., 1001184., 1005168., 1009152.};
  const std::array<int, 4> in_shape = {{3, 6, 4, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x6x5x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {162750., 203700., 163050.,
                                         197580., 247065., 197580.,
                                         163050., 203700., 162750.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x6x5x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {35646., 36312., 36978., 38976., 39642.,
                                         40308., 42306., 42972., 43638.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x6x5x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      322950., 325500., 404175., 407400., 323490., 326100.,
      391920., 395160., 490035., 494130., 391848., 395160.,
      323250., 326100., 403800., 407400., 322590., 325500.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x6x5x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      69870., 71292., 71166., 72624., 72462., 73956., 76350., 77952., 77646.,
      79284., 78942., 80616., 82830., 84612., 84126., 85944., 85422., 87276.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x6x5x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      643350., 645900., 648450., 651000., 805125., 808350., 811575., 814800.,
      644370., 646980., 649590., 652200., 780600., 783840., 787080., 790320.,
      975975., 980070., 984165., 988260., 780384., 783696., 787008., 790320.,
      643650., 646500., 649350., 652200., 804000., 807600., 811200., 814800.,
      642270., 645180., 648090., 651000.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x6x5x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      138318., 139740., 141162., 142584., 140874., 142332., 143790., 145248.,
      143430., 144924., 146418., 147912., 151098., 152700., 154302., 155904.,
      153654., 155292., 156930., 158568., 156210., 157884., 159558., 161232.,
      163878., 165660., 167442., 169224., 166434., 168252., 170070., 171888.,
      168990., 170844., 172698., 174552.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x6x5x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      640140., 651000., 801225., 814800., 641340., 652200.,
      777288., 790320., 971970., 988260., 777288., 790320.,
      641340., 652200., 801225., 814800., 640140., 651000.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x6x5x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      138444., 142584., 141036., 145248., 143628., 147912.,
      151404., 155904., 153996., 158568., 156588., 161232.,
      164364., 169224., 166956., 171888., 169548., 174552.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x6x5x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1275240., 1280280., 1296900., 1302000., 1596075., 1602450.,
      1623150., 1629600., 1277520., 1282680., 1299180., 1304400.,
      1548168., 1554576., 1574160., 1580640., 1935840., 1943940.,
      1968330., 1976520., 1548024., 1554576., 1574016., 1580640.,
      1277040., 1282680., 1298700., 1304400., 1595325., 1602450.,
      1622400., 1629600., 1274520., 1280280., 1296180., 1302000.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x6x5x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      274080., 276888., 282324., 285168., 279192., 282072., 287580., 290496.,
      284304., 287256., 292836., 295824., 299640., 302808., 308604., 311808.,
      304752., 307992., 313860., 317136., 309864., 313176., 319116., 322464.,
      325200., 328728., 334884., 338448., 330312., 333912., 340140., 343776.,
      335424., 339096., 345396., 349104.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x6x5x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2545440., 2550480., 2555520., 2560560., 2588700., 2593800., 2598900.,
      2604000., 3185775., 3192150., 3198525., 3204900., 3239850., 3246300.,
      3252750., 3259200., 2549880., 2555040., 2560200., 2565360., 2593140.,
      2598360., 2603580., 2608800., 3089928., 3096336., 3102744., 3109152.,
      3141840., 3148320., 3154800., 3161280., 3863580., 3871680., 3879780.,
      3887880., 3928470., 3936660., 3944850., 3953040., 3089496., 3096048.,
      3102600., 3109152., 3141408., 3148032., 3154656., 3161280., 2548440.,
      2554080., 2559720., 2565360., 2591700., 2597400., 2603100., 2608800.,
      3183525., 3190650., 3197775., 3204900., 3237600., 3244800., 3252000.,
      3259200., 2543280., 2549040., 2554800., 2560560., 2586540., 2592360.,
      2598180., 2604000.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x6x5x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      545352., 548160., 550968., 553776., 561804., 564648., 567492., 570336.,
      555504., 558384., 561264., 564144., 572244., 575160., 578076., 580992.,
      565656., 568608., 571560., 574512., 582684., 585672., 588660., 591648.,
      596112., 599280., 602448., 605616., 614004., 617208., 620412., 623616.,
      606264., 609504., 612744., 615984., 624444., 627720., 630996., 634272.,
      616416., 619728., 623040., 626352., 634884., 638232., 641580., 644928.,
      646872., 650400., 653928., 657456., 666204., 669768., 673332., 676896.,
      657024., 660624., 664224., 667824., 676644., 680280., 683916., 687552.,
      667176., 670848., 674520., 678192., 687084., 690792., 694500., 698208.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x6x5x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2539020., 2560560., 2582220., 2604000., 3177975., 3204900.,
      3231975., 3259200., 2543820., 2565360., 2587020., 2608800.,
      3083304., 3109152., 3135144., 3161280., 3855570., 3887880.,
      3920370., 3953040., 3083304., 3109152., 3135144., 3161280.,
      2543820., 2565360., 2587020., 2608800., 3177975., 3204900.,
      3231975., 3259200., 2539020., 2560560., 2582220., 2604000.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x6x5x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      545604., 553776., 562020., 570336., 555828., 564144., 572532., 580992.,
      566052., 574512., 583044., 591648., 596724., 605616., 614580., 623616.,
      606948., 615984., 625092., 634272., 617172., 626352., 635604., 644928.,
      647844., 657456., 667140., 676896., 658068., 667824., 677652., 687552.,
      668292., 678192., 688164., 698208.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x6x5x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5068020., 5078040., 5111040., 5121120., 5154300., 5164440., 5197800.,
      5208000., 6343275., 6355950., 6397050., 6409800., 6451125., 6463950.,
      6505500., 6518400., 5077380., 5087640., 5120400., 5130720., 5163660.,
      5174040., 5207160., 5217600., 6153864., 6166608., 6205488., 6218304.,
      6257400., 6270288., 6309600., 6322560., 7695030., 7711140., 7759560.,
      7775760., 7824450., 7840740., 7889700., 7906080., 6153576., 6166608.,
      6205200., 6218304., 6257112., 6270288., 6309312., 6322560., 5076420.,
      5087640., 5119440., 5130720., 5162700., 5174040., 5206200., 5217600.,
      6341775., 6355950., 6395550., 6409800., 6449625., 6463950., 6504000.,
      6518400., 5066580., 5078040., 5109600., 5121120., 5152860., 5164440.,
      5196360., 5208000.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x6x5x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1085628., 1091208., 1101936., 1107552., 1118388., 1124040., 1134984.,
      1140672., 1105932., 1111656., 1122528., 1128288., 1139268., 1145064.,
      1156152., 1161984., 1126236., 1132104., 1143120., 1149024., 1160148.,
      1166088., 1177320., 1183296., 1187148., 1193448., 1204896., 1211232.,
      1222788., 1229160., 1240824., 1247232., 1207452., 1213896., 1225488.,
      1231968., 1243668., 1250184., 1261992., 1268544., 1227756., 1234344.,
      1246080., 1252704., 1264548., 1271208., 1283160., 1289856., 1288668.,
      1295688., 1307856., 1314912., 1327188., 1334280., 1346664., 1353792.,
      1308972., 1316136., 1328448., 1335648., 1348068., 1355304., 1367832.,
      1375104., 1329276., 1336584., 1349040., 1356384., 1368948., 1376328.,
      1389000., 1396416.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x6x5x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      10126020., 10136040., 10146060., 10156080., 10212000., 10222080.,
      10232160., 10242240., 10298460., 10308600., 10318740., 10328880.,
      10385400., 10395600., 10405800., 10416000., 12673875., 12686550.,
      12699225., 12711900., 12781350., 12794100., 12806850., 12819600.,
      12889425., 12902250., 12915075., 12927900., 12998100., 13011000.,
      13023900., 13036800., 10144500., 10154760., 10165020., 10175280.,
      10230480., 10240800., 10251120., 10261440., 10316940., 10327320.,
      10337700., 10348080., 10403880., 10414320., 10424760., 10435200.,
      12294984., 12307728., 12320472., 12333216., 12398160., 12410976.,
      12423792., 12436608., 12501912., 12514800., 12527688., 12540576.,
      12606240., 12619200., 12632160., 12645120., 15373950., 15390060.,
      15406170., 15422280., 15502920., 15519120., 15535320., 15551520.,
      15632610., 15648900., 15665190., 15681480., 15763020., 15779400.,
      15795780., 15812160., 12294120., 12307152., 12320184., 12333216.,
      12397296., 12410400., 12423504., 12436608., 12501048., 12514224.,
      12527400., 12540576., 12605376., 12618624., 12631872., 12645120.,
      10141620., 10152840., 10164060., 10175280., 10227600., 10238880.,
      10250160., 10261440., 10314060., 10325400., 10336740., 10348080.,
      10401000., 10412400., 10423800., 10435200., 12669375., 12683550.,
      12697725., 12711900., 12776850., 12791100., 12805350., 12819600.,
      12884925., 12899250., 12913575., 12927900., 12993600., 13008000.,
      13022400., 13036800., 10121700., 10133160., 10144620., 10156080.,
      10207680., 10219200., 10230720., 10242240., 10294140., 10305720.,
      10317300., 10328880., 10381080., 10392720., 10404360., 10416000.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x6x5x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2165676., 2171256., 2176836., 2182416., 2198256., 2203872., 2209488.,
      2215104., 2231124., 2236776., 2242428., 2248080., 2264280., 2269968.,
      2275656., 2281344., 2206140., 2211864., 2217588., 2223312., 2239296.,
      2245056., 2250816., 2256576., 2272740., 2278536., 2284332., 2290128.,
      2306472., 2312304., 2318136., 2323968., 2246604., 2252472., 2258340.,
      2264208., 2280336., 2286240., 2292144., 2298048., 2314356., 2320296.,
      2326236., 2332176., 2348664., 2354640., 2360616., 2366592., 2367996.,
      2374296., 2380596., 2386896., 2403456., 2409792., 2416128., 2422464.,
      2439204., 2445576., 2451948., 2458320., 2475240., 2481648., 2488056.,
      2494464., 2408460., 2414904., 2421348., 2427792., 2444496., 2450976.,
      2457456., 2463936., 2480820., 2487336., 2493852., 2500368., 2517432.,
      2523984., 2530536., 2537088., 2448924., 2455512., 2462100., 2468688.,
      2485536., 2492160., 2498784., 2505408., 2522436., 2529096., 2535756.,
      2542416., 2559624., 2566320., 2573016., 2579712., 2570316., 2577336.,
      2584356., 2591376., 2608656., 2615712., 2622768., 2629824., 2647284.,
      2654376., 2661468., 2668560., 2686200., 2693328., 2700456., 2707584.,
      2610780., 2617944., 2625108., 2632272., 2649696., 2656896., 2664096.,
      2671296., 2688900., 2696136., 2703372., 2710608., 2728392., 2735664.,
      2742936., 2750208., 2651244., 2658552., 2665860., 2673168., 2690736.,
      2698080., 2705424., 2712768., 2730516., 2737896., 2745276., 2752656.,
      2770584., 2778000., 2785416., 2792832.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x6x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {292200., 351015., 292650.,
                                         354690., 425754., 354690.,
                                         292650., 351015., 292200.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x6x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {75792., 76968., 78144., 82848., 84024.,
                                         85200., 89904., 91080., 92256.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 1}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x6x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      580575., 584400., 697395., 702030., 581400., 585300.,
      704520., 709380., 845622., 851508., 704430., 709380.,
      581025., 585300., 696855., 702030., 580050., 584400.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x6x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      149304., 151584., 151608., 153936., 153912., 156288.,
      163128., 165696., 165432., 168048., 167736., 170400.,
      176952., 179808., 179256., 182160., 181560., 184512.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 1}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x6x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1157325., 1161150., 1164975., 1168800., 1390155., 1394790.,
      1399425., 1404060., 1158900., 1162800., 1166700., 1170600.,
      1404180., 1409040., 1413900., 1418760., 1685358., 1691244.,
      1697130., 1703016., 1403910., 1408860., 1413810., 1418760.,
      1157775., 1162050., 1166325., 1170600., 1388535., 1393710.,
      1398885., 1404060., 1155750., 1160100., 1164450., 1168800.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x6x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      296328., 298608., 300888., 303168., 300888., 303216., 305544., 307872.,
      305448., 307824., 310200., 312576., 323688., 326256., 328824., 331392.,
      328248., 330864., 333480., 336096., 332808., 335472., 338136., 340800.,
      351048., 353904., 356760., 359616., 355608., 358512., 361416., 364320.,
      360168., 363120., 366072., 369024.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 1}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x6x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1152525., 1168800., 1384530., 1404060., 1154325., 1170600.,
      1399230., 1418760., 1679580., 1703016., 1399230., 1418760.,
      1154325., 1170600., 1384530., 1404060., 1152525., 1168800.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x6x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      296304., 303168., 300912., 307872., 305520., 312576.,
      323952., 331392., 328560., 336096., 333168., 340800.,
      351600., 359616., 356208., 364320., 360816., 369024.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 2}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x6x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2297475., 2305050., 2329950., 2337600., 2759880., 2769060.,
      2798850., 2808120., 2300925., 2308650., 2333400., 2341200.,
      2788830., 2798460., 2827800., 2837520., 3347496., 3359160.,
      3394260., 3406032., 2788650., 2798460., 2827620., 2837520.,
      2300175., 2308650., 2332650., 2341200., 2758800., 2769060.,
      2797770., 2808120., 2296425., 2305050., 2328900., 2337600.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x6x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      588096., 592608., 601776., 606336., 597216., 601824., 611088., 615744.,
      606336., 611040., 620400., 625152., 642816., 647904., 657648., 662784.,
      651936., 657120., 666960., 672192., 661056., 666336., 676272., 681600.,
      697536., 703200., 713520., 719232., 706656., 712416., 722832., 728640.,
      715776., 721632., 732144., 738048.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 2}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x6x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      4587375., 4594950., 4602525., 4610100., 4652250., 4659900., 4667550.,
      4675200., 5510580., 5519760., 5528940., 5538120., 5588430., 5597700.,
      5606970., 5616240., 4594125., 4601850., 4609575., 4617300., 4659000.,
      4666800., 4674600., 4682400., 5568030., 5577660., 5587290., 5596920.,
      5645880., 5655600., 5665320., 5675040., 6683328., 6694992., 6706656.,
      6718320., 6776748., 6788520., 6800292., 6812064., 5567490., 5577300.,
      5587110., 5596920., 5645340., 5655240., 5665140., 5675040., 4591875.,
      4600350., 4608825., 4617300., 4656750., 4665300., 4673850., 4682400.,
      5507340., 5517600., 5527860., 5538120., 5585190., 5595540., 5605890.,
      5616240., 4584225., 4592850., 4601475., 4610100., 4649100., 4657800.,
      4666500., 4675200.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x6x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1171680., 1176192., 1180704., 1185216., 1198992., 1203552., 1208112.,
      1212672., 1189824., 1194432., 1199040., 1203648., 1217520., 1222176.,
      1226832., 1231488., 1207968., 1212672., 1217376., 1222080., 1236048.,
      1240800., 1245552., 1250304., 1280544., 1285632., 1290720., 1295808.,
      1310160., 1315296., 1320432., 1325568., 1298688., 1303872., 1309056.,
      1314240., 1328688., 1333920., 1339152., 1344384., 1316832., 1322112.,
      1327392., 1332672., 1347216., 1352544., 1357872., 1363200., 1389408.,
      1395072., 1400736., 1406400., 1421328., 1427040., 1432752., 1438464.,
      1407552., 1413312., 1419072., 1424832., 1439856., 1445664., 1451472.,
      1457280., 1425696., 1431552., 1437408., 1443264., 1458384., 1464288.,
      1470192., 1476096.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 2}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x6x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      4577775., 4610100., 4642575., 4675200., 5499330., 5538120.,
      5577090., 5616240., 4584975., 4617300., 4649775., 4682400.,
      5558130., 5596920., 5635890., 5675040., 6671772., 6718320.,
      6765084., 6812064., 5558130., 5596920., 5635890., 5675040.,
      4584975., 4617300., 4649775., 4682400., 5499330., 5538120.,
      5577090., 5616240., 4577775., 4610100., 4642575., 4675200.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x6x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1171632., 1185216., 1198896., 1212672., 1189872., 1203648.,
      1217520., 1231488., 1208112., 1222080., 1236144., 1250304.,
      1281072., 1295808., 1310640., 1325568., 1299312., 1314240.,
      1329264., 1344384., 1317552., 1332672., 1347888., 1363200.,
      1390512., 1406400., 1422384., 1438464., 1408752., 1424832.,
      1441008., 1457280., 1426992., 1443264., 1459632., 1476096.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 4}};
  const int multiplier = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x6x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      9140475.,  9155550.,  9205050.,  9220200.,  9269925.,  9285150.,
      9335100.,  9350400.,  10980390., 10998660., 11057880., 11076240.,
      11135730., 11154180., 11213940., 11232480., 9154575.,  9169950.,
      9219150.,  9234600.,  9284025.,  9299550.,  9349200.,  9364800.,
      11097090., 11116260., 11174580., 11193840., 11252430., 11271780.,
      11330640., 11350080., 13320324., 13343544., 13413312., 13436640.,
      13506732., 13530168., 13600584., 13624128., 11096730., 11116260.,
      11174220., 11193840., 11252070., 11271780., 11330280., 11350080.,
      9153075.,  9169950.,  9217650.,  9234600.,  9282525.,  9299550.,
      9347700.,  9364800.,  10978230., 10998660., 11055720., 11076240.,
      11133570., 11154180., 11211780., 11232480., 9138375.,  9155550.,
      9202950.,  9220200.,  9267825.,  9285150.,  9333000.,  9350400.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x6x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2334288., 2343264., 2361408., 2370432., 2388720., 2397792., 2416224.,
      2425344., 2370576., 2379744., 2398080., 2407296., 2425776., 2435040.,
      2453664., 2462976., 2406864., 2416224., 2434752., 2444160., 2462832.,
      2472288., 2491104., 2500608., 2552016., 2562144., 2581440., 2591616.,
      2611056., 2621280., 2640864., 2651136., 2588304., 2598624., 2618112.,
      2628480., 2648112., 2658528., 2678304., 2688768., 2624592., 2635104.,
      2654784., 2665344., 2685168., 2695776., 2715744., 2726400., 2769744.,
      2781024., 2801472., 2812800., 2833392., 2844768., 2865504., 2876928.,
      2806032., 2817504., 2838144., 2849664., 2870448., 2882016., 2902944.,
      2914560., 2842320., 2853984., 2874816., 2886528., 2907504., 2919264.,
      2940384., 2952192.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 4}};
  const int multiplier = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, SAME3x6x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      7685907.,  7700982.,  7716057.,  7731132.,  7782214.,  7797364.,
      7812514.,  7827664.,  7879121.,  7894346.,  7909571.,  7924796.,
      7976628.,  7991928.,  8007228.,  8022528.,  9259246.,  9277516.,
      9295786.,  9314056.,  9375224.,  9393584.,  9411944.,  9430304.,
      9491922.,  9510372.,  9528822.,  9547272.,  9609340.,  9627880.,
      9646420.,  9664960.,  7821327.,  7836702.,  7852077.,  7867452.,
      7918658.,  7934108.,  7949558.,  7965008.,  8016589.,  8032114.,
      8047639.,  8063164.,  8115120.,  8130720.,  8146320.,  8161920.,
      9287970.,  9307140.,  9326310.,  9345480.,  9404972.,  9424232.,
      9443492.,  9462752.,  9522694.,  9542044.,  9561394.,  9580744.,
      9641136.,  9660576.,  9680016.,  9699456.,  11163220., 11186440.,
      11209660., 11232880., 11304032., 11327360., 11350688., 11374016.,
      11445708., 11469144., 11492580., 11516016., 11588248., 11611792.,
      11635336., 11658880., 9398506.,  9418036.,  9437566.,  9457096.,
      9516532.,  9536152.,  9555772.,  9575392.,  9635278.,  9654988.,
      9674698.,  9694408.,  9754744.,  9774544.,  9794344.,  9814144.,
      8271483.,  8288358.,  8305233.,  8322108.,  8372910.,  8389860.,
      8406810.,  8423760.,  8474937.,  8491962.,  8508987.,  8526012.,
      8577564.,  8594664.,  8611764.,  8628864.,  9959326.,  9979756.,
      10000186., 10020616., 10081448., 10101968., 10122488., 10143008.,
      10204290., 10224900., 10245510., 10266120., 10327852., 10348552.,
      10369252., 10389952., 8418935.,  8436110.,  8453285.,  8470460.,
      8521386.,  8538636.,  8555886.,  8573136.,  8624437.,  8641762.,
      8659087.,  8676412.,  8728088.,  8745488.,  8762888.,  8780288.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 1024.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow3Stride1, VALID3x6x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      4659600., 4668576., 4677552., 4686528., 4713792., 4722816., 4731840.,
      4740864., 4768368., 4777440., 4786512., 4795584., 4823328., 4832448.,
      4841568., 4850688., 4731984., 4741152., 4750320., 4759488., 4786944.,
      4796160., 4805376., 4814592., 4842288., 4851552., 4860816., 4870080.,
      4898016., 4907328., 4916640., 4925952., 4804368., 4813728., 4823088.,
      4832448., 4860096., 4869504., 4878912., 4888320., 4916208., 4925664.,
      4935120., 4944576., 4972704., 4982208., 4991712., 5001216., 5093904.,
      5104032., 5114160., 5124288., 5152704., 5162880., 5173056., 5183232.,
      5211888., 5222112., 5232336., 5242560., 5271456., 5281728., 5292000.,
      5302272., 5166288., 5176608., 5186928., 5197248., 5225856., 5236224.,
      5246592., 5256960., 5285808., 5296224., 5306640., 5317056., 5346144.,
      5356608., 5367072., 5377536., 5238672., 5249184., 5259696., 5270208.,
      5299008., 5309568., 5320128., 5330688., 5359728., 5370336., 5380944.,
      5391552., 5420832., 5431488., 5442144., 5452800., 5528208., 5539488.,
      5550768., 5562048., 5591616., 5602944., 5614272., 5625600., 5655408.,
      5666784., 5678160., 5689536., 5719584., 5731008., 5742432., 5753856.,
      5600592., 5612064., 5623536., 5635008., 5664768., 5676288., 5687808.,
      5699328., 5729328., 5740896., 5752464., 5764032., 5794272., 5805888.,
      5817504., 5829120., 5672976., 5684640., 5696304., 5707968., 5737920.,
      5749632., 5761344., 5773056., 5803248., 5815008., 5826768., 5838528.,
      5868960., 5880768., 5892576., 5904384.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 4}};
  const int multiplier = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, multiplier, padding,
                                 max_input_val);
}